524 lines
28 KiB
Markdown
524 lines
28 KiB
Markdown
# System.Threading
|
|
|
|
``` diff
|
|
+namespace System.Threading {
|
|
+ public class AbandonedMutexException : Exception {
|
|
+ public AbandonedMutexException();
|
|
+ public AbandonedMutexException(int location, WaitHandle handle);
|
|
+ public AbandonedMutexException(string message);
|
|
+ public AbandonedMutexException(string message, Exception inner);
|
|
+ public AbandonedMutexException(string message, Exception inner, int location, WaitHandle handle);
|
|
+ public AbandonedMutexException(string message, int location, WaitHandle handle);
|
|
+ public Mutex Mutex { get; }
|
|
+ public int MutexIndex { get; }
|
|
+ }
|
|
+ public sealed class AsyncLocal<T> {
|
|
+ public AsyncLocal();
|
|
+ public AsyncLocal(Action<AsyncLocalValueChangedArgs<T>> valueChangedHandler);
|
|
+ public T Value { get; set; }
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct AsyncLocalValueChangedArgs<T> {
|
|
+ public T CurrentValue { get; }
|
|
+ public T PreviousValue { get; }
|
|
+ public bool ThreadContextChanged { get; }
|
|
+ }
|
|
+ public sealed class AutoResetEvent : EventWaitHandle {
|
|
+ public AutoResetEvent(bool initialState);
|
|
+ }
|
|
+ public class Barrier : IDisposable {
|
|
+ public Barrier(int participantCount);
|
|
+ public Barrier(int participantCount, Action<Barrier> postPhaseAction);
|
|
+ public long CurrentPhaseNumber { get; }
|
|
+ public int ParticipantCount { get; }
|
|
+ public int ParticipantsRemaining { get; }
|
|
+ public long AddParticipant();
|
|
+ public long AddParticipants(int participantCount);
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ public void RemoveParticipant();
|
|
+ public void RemoveParticipants(int participantCount);
|
|
+ public void SignalAndWait();
|
|
+ public bool SignalAndWait(int millisecondsTimeout);
|
|
+ public bool SignalAndWait(int millisecondsTimeout, CancellationToken cancellationToken);
|
|
+ public void SignalAndWait(CancellationToken cancellationToken);
|
|
+ public bool SignalAndWait(TimeSpan timeout);
|
|
+ public bool SignalAndWait(TimeSpan timeout, CancellationToken cancellationToken);
|
|
+ }
|
|
+ public class BarrierPostPhaseException : Exception {
|
|
+ public BarrierPostPhaseException();
|
|
+ public BarrierPostPhaseException(Exception innerException);
|
|
+ public BarrierPostPhaseException(string message);
|
|
+ public BarrierPostPhaseException(string message, Exception innerException);
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct CancellationToken {
|
|
+ public CancellationToken(bool canceled);
|
|
+ public bool CanBeCanceled { get; }
|
|
+ public bool IsCancellationRequested { get; }
|
|
+ public static CancellationToken None { get; }
|
|
+ public WaitHandle WaitHandle { get; }
|
|
+ public override bool Equals(object other);
|
|
+ public bool Equals(CancellationToken other);
|
|
+ public override int GetHashCode();
|
|
+ public static bool operator ==(CancellationToken left, CancellationToken right);
|
|
+ public static bool operator !=(CancellationToken left, CancellationToken right);
|
|
+ public CancellationTokenRegistration Register(Action callback);
|
|
+ public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext);
|
|
+ public CancellationTokenRegistration Register(Action<object> callback, object state);
|
|
+ public CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext);
|
|
+ public void ThrowIfCancellationRequested();
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
|
|
+ public void Dispose();
|
|
+ public override bool Equals(object obj);
|
|
+ public bool Equals(CancellationTokenRegistration other);
|
|
+ public override int GetHashCode();
|
|
+ public static bool operator ==(CancellationTokenRegistration left, CancellationTokenRegistration right);
|
|
+ public static bool operator !=(CancellationTokenRegistration left, CancellationTokenRegistration right);
|
|
+ }
|
|
+ public class CancellationTokenSource : IDisposable {
|
|
+ public CancellationTokenSource();
|
|
+ public CancellationTokenSource(int millisecondsDelay);
|
|
+ public CancellationTokenSource(TimeSpan delay);
|
|
+ public bool IsCancellationRequested { get; }
|
|
+ public CancellationToken Token { get; }
|
|
+ public void Cancel();
|
|
+ public void Cancel(bool throwOnFirstException);
|
|
+ public void CancelAfter(int millisecondsDelay);
|
|
+ public void CancelAfter(TimeSpan delay);
|
|
+ public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2);
|
|
+ public static CancellationTokenSource CreateLinkedTokenSource(params CancellationToken[] tokens);
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ }
|
|
+ public delegate void ContextCallback(object state);
|
|
+ public class CountdownEvent : IDisposable {
|
|
+ public CountdownEvent(int initialCount);
|
|
+ public int CurrentCount { get; }
|
|
+ public int InitialCount { get; }
|
|
+ public bool IsSet { get; }
|
|
+ public WaitHandle WaitHandle { get; }
|
|
+ public void AddCount();
|
|
+ public void AddCount(int signalCount);
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ public void Reset();
|
|
+ public void Reset(int count);
|
|
+ public bool Signal();
|
|
+ public bool Signal(int signalCount);
|
|
+ public bool TryAddCount();
|
|
+ public bool TryAddCount(int signalCount);
|
|
+ public void Wait();
|
|
+ public bool Wait(int millisecondsTimeout);
|
|
+ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
|
|
+ public void Wait(CancellationToken cancellationToken);
|
|
+ public bool Wait(TimeSpan timeout);
|
|
+ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
|
|
+ }
|
|
+ public enum EventResetMode {
|
|
+ AutoReset = 0,
|
|
+ ManualReset = 1,
|
|
+ }
|
|
+ public class EventWaitHandle : WaitHandle {
|
|
+ public EventWaitHandle(bool initialState, EventResetMode mode);
|
|
+ public EventWaitHandle(bool initialState, EventResetMode mode, string name);
|
|
+ public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew);
|
|
+ public static EventWaitHandle OpenExisting(string name);
|
|
+ public bool Reset();
|
|
+ public bool Set();
|
|
+ public static bool TryOpenExisting(string name, out EventWaitHandle result);
|
|
+ }
|
|
+ public sealed class ExecutionContext {
|
|
+ public static ExecutionContext Capture();
|
|
+ public void Dispose();
|
|
+ public static void Run(ExecutionContext executionContext, ContextCallback callback, object state);
|
|
+ }
|
|
+ public static class Interlocked {
|
|
+ public static int Add(ref int location1, int value);
|
|
+ public static long Add(ref long location1, long value);
|
|
+ public static double CompareExchange(ref double location1, double value, double comparand);
|
|
+ public static int CompareExchange(ref int location1, int value, int comparand);
|
|
+ public static long CompareExchange(ref long location1, long value, long comparand);
|
|
+ public static IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);
|
|
+ public static object CompareExchange(ref object location1, object value, object comparand);
|
|
+ public static float CompareExchange(ref float location1, float value, float comparand);
|
|
+ public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class;
|
|
+ public static int Decrement(ref int location);
|
|
+ public static long Decrement(ref long location);
|
|
+ public static double Exchange(ref double location1, double value);
|
|
+ public static int Exchange(ref int location1, int value);
|
|
+ public static long Exchange(ref long location1, long value);
|
|
+ public static IntPtr Exchange(ref IntPtr location1, IntPtr value);
|
|
+ public static object Exchange(ref object location1, object value);
|
|
+ public static float Exchange(ref float location1, float value);
|
|
+ public static T Exchange<T>(ref T location1, T value) where T : class;
|
|
+ public static int Increment(ref int location);
|
|
+ public static long Increment(ref long location);
|
|
+ public static void MemoryBarrier();
|
|
+ public static long Read(ref long location);
|
|
+ }
|
|
+ public unsafe delegate void IOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP);
|
|
+ public static class LazyInitializer {
|
|
+ public static T EnsureInitialized<T>(ref T target) where T : class;
|
|
+ public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock);
|
|
+ public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock, Func<T> valueFactory);
|
|
+ public static T EnsureInitialized<T>(ref T target, Func<T> valueFactory) where T : class;
|
|
+ }
|
|
+ public enum LazyThreadSafetyMode {
|
|
+ ExecutionAndPublication = 2,
|
|
+ None = 0,
|
|
+ PublicationOnly = 1,
|
|
+ }
|
|
+ public class LockRecursionException : Exception {
|
|
+ public LockRecursionException();
|
|
+ public LockRecursionException(string message);
|
|
+ public LockRecursionException(string message, Exception innerException);
|
|
+ }
|
|
+ public enum LockRecursionPolicy {
|
|
+ NoRecursion = 0,
|
|
+ SupportsRecursion = 1,
|
|
+ }
|
|
+ public sealed class ManualResetEvent : EventWaitHandle {
|
|
+ public ManualResetEvent(bool initialState);
|
|
+ }
|
|
+ public class ManualResetEventSlim : IDisposable {
|
|
+ public ManualResetEventSlim();
|
|
+ public ManualResetEventSlim(bool initialState);
|
|
+ public ManualResetEventSlim(bool initialState, int spinCount);
|
|
+ public bool IsSet { get; }
|
|
+ public int SpinCount { get; }
|
|
+ public WaitHandle WaitHandle { get; }
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ public void Reset();
|
|
+ public void Set();
|
|
+ public void Wait();
|
|
+ public bool Wait(int millisecondsTimeout);
|
|
+ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
|
|
+ public void Wait(CancellationToken cancellationToken);
|
|
+ public bool Wait(TimeSpan timeout);
|
|
+ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
|
|
+ }
|
|
+ public static class Monitor {
|
|
+ public static void Enter(object obj);
|
|
+ public static void Enter(object obj, ref bool lockTaken);
|
|
+ public static void Exit(object obj);
|
|
+ public static bool IsEntered(object obj);
|
|
+ public static void Pulse(object obj);
|
|
+ public static void PulseAll(object obj);
|
|
+ public static bool TryEnter(object obj);
|
|
+ public static void TryEnter(object obj, ref bool lockTaken);
|
|
+ public static bool TryEnter(object obj, int millisecondsTimeout);
|
|
+ public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken);
|
|
+ public static bool TryEnter(object obj, TimeSpan timeout);
|
|
+ public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken);
|
|
+ public static bool Wait(object obj);
|
|
+ public static bool Wait(object obj, int millisecondsTimeout);
|
|
+ public static bool Wait(object obj, TimeSpan timeout);
|
|
+ }
|
|
+ public sealed class Mutex : WaitHandle {
|
|
+ public Mutex();
|
|
+ public Mutex(bool initiallyOwned);
|
|
+ public Mutex(bool initiallyOwned, string name);
|
|
+ public Mutex(bool initiallyOwned, string name, out bool createdNew);
|
|
+ public static Mutex OpenExisting(string name);
|
|
+ public void ReleaseMutex();
|
|
+ public static bool TryOpenExisting(string name, out Mutex result);
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct NativeOverlapped {
|
|
+ public int OffsetHigh;
|
|
+ public int OffsetLow;
|
|
+ public IntPtr EventHandle;
|
|
+ public IntPtr InternalHigh;
|
|
+ public IntPtr InternalLow;
|
|
+ }
|
|
+ public class Overlapped {
|
|
+ public Overlapped();
|
|
+ public IAsyncResult AsyncResult { get; set; }
|
|
+ public int OffsetHigh { get; set; }
|
|
+ public int OffsetLow { get; set; }
|
|
+ public unsafe static void Free(NativeOverlapped* nativeOverlappedPtr);
|
|
+ public unsafe NativeOverlapped* Pack(IOCompletionCallback iocb, object userData);
|
|
+ public unsafe static Overlapped Unpack(NativeOverlapped* nativeOverlappedPtr);
|
|
+ public unsafe NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData);
|
|
+ }
|
|
+ public delegate void ParameterizedThreadStart(object obj);
|
|
+ public sealed class PreAllocatedOverlapped : IDisposable {
|
|
+ public PreAllocatedOverlapped(IOCompletionCallback callback, object state, object pinData);
|
|
+ public void Dispose();
|
|
+ }
|
|
+ public class ReaderWriterLockSlim : IDisposable {
|
|
+ public ReaderWriterLockSlim();
|
|
+ public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy);
|
|
+ public int CurrentReadCount { get; }
|
|
+ public bool IsReadLockHeld { get; }
|
|
+ public bool IsUpgradeableReadLockHeld { get; }
|
|
+ public bool IsWriteLockHeld { get; }
|
|
+ public LockRecursionPolicy RecursionPolicy { get; }
|
|
+ public int RecursiveReadCount { get; }
|
|
+ public int RecursiveUpgradeCount { get; }
|
|
+ public int RecursiveWriteCount { get; }
|
|
+ public int WaitingReadCount { get; }
|
|
+ public int WaitingUpgradeCount { get; }
|
|
+ public int WaitingWriteCount { get; }
|
|
+ public void Dispose();
|
|
+ public void EnterReadLock();
|
|
+ public void EnterUpgradeableReadLock();
|
|
+ public void EnterWriteLock();
|
|
+ public void ExitReadLock();
|
|
+ public void ExitUpgradeableReadLock();
|
|
+ public void ExitWriteLock();
|
|
+ public bool TryEnterReadLock(int millisecondsTimeout);
|
|
+ public bool TryEnterReadLock(TimeSpan timeout);
|
|
+ public bool TryEnterUpgradeableReadLock(int millisecondsTimeout);
|
|
+ public bool TryEnterUpgradeableReadLock(TimeSpan timeout);
|
|
+ public bool TryEnterWriteLock(int millisecondsTimeout);
|
|
+ public bool TryEnterWriteLock(TimeSpan timeout);
|
|
+ }
|
|
+ public sealed class RegisteredWaitHandle {
|
|
+ public bool Unregister(WaitHandle waitObject);
|
|
+ }
|
|
+ public sealed class Semaphore : WaitHandle {
|
|
+ public Semaphore(int initialCount, int maximumCount);
|
|
+ public Semaphore(int initialCount, int maximumCount, string name);
|
|
+ public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew);
|
|
+ public static Semaphore OpenExisting(string name);
|
|
+ public int Release();
|
|
+ public int Release(int releaseCount);
|
|
+ public static bool TryOpenExisting(string name, out Semaphore result);
|
|
+ }
|
|
+ public class SemaphoreFullException : Exception {
|
|
+ public SemaphoreFullException();
|
|
+ public SemaphoreFullException(string message);
|
|
+ public SemaphoreFullException(string message, Exception innerException);
|
|
+ }
|
|
+ public class SemaphoreSlim : IDisposable {
|
|
+ public SemaphoreSlim(int initialCount);
|
|
+ public SemaphoreSlim(int initialCount, int maxCount);
|
|
+ public WaitHandle AvailableWaitHandle { get; }
|
|
+ public int CurrentCount { get; }
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ public int Release();
|
|
+ public int Release(int releaseCount);
|
|
+ public void Wait();
|
|
+ public bool Wait(int millisecondsTimeout);
|
|
+ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
|
|
+ public void Wait(CancellationToken cancellationToken);
|
|
+ public bool Wait(TimeSpan timeout);
|
|
+ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
|
|
+ public Task WaitAsync();
|
|
+ public Task<bool> WaitAsync(int millisecondsTimeout);
|
|
+ public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellationToken);
|
|
+ public Task WaitAsync(CancellationToken cancellationToken);
|
|
+ public Task<bool> WaitAsync(TimeSpan timeout);
|
|
+ public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken);
|
|
+ }
|
|
+ public delegate void SendOrPostCallback(object state);
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct SpinLock {
|
|
+ public SpinLock(bool enableThreadOwnerTracking);
|
|
+ public bool IsHeld { get; }
|
|
+ public bool IsHeldByCurrentThread { get; }
|
|
+ public bool IsThreadOwnerTrackingEnabled { get; }
|
|
+ public void Enter(ref bool lockTaken);
|
|
+ public void Exit();
|
|
+ public void Exit(bool useMemoryBarrier);
|
|
+ public void TryEnter(ref bool lockTaken);
|
|
+ public void TryEnter(int millisecondsTimeout, ref bool lockTaken);
|
|
+ public void TryEnter(TimeSpan timeout, ref bool lockTaken);
|
|
+ }
|
|
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
+ public struct SpinWait {
|
|
+ public int Count { get; }
|
|
+ public bool NextSpinWillYield { get; }
|
|
+ public void Reset();
|
|
+ public void SpinOnce();
|
|
+ public static void SpinUntil(Func<bool> condition);
|
|
+ public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout);
|
|
+ public static bool SpinUntil(Func<bool> condition, TimeSpan timeout);
|
|
+ }
|
|
+ public class SynchronizationContext {
|
|
+ public SynchronizationContext();
|
|
+ public static SynchronizationContext Current { get; }
|
|
+ public virtual SynchronizationContext CreateCopy();
|
|
+ public virtual void OperationCompleted();
|
|
+ public virtual void OperationStarted();
|
|
+ public virtual void Post(SendOrPostCallback d, object state);
|
|
+ public virtual void Send(SendOrPostCallback d, object state);
|
|
+ public static void SetSynchronizationContext(SynchronizationContext syncContext);
|
|
+ }
|
|
+ public class SynchronizationLockException : Exception {
|
|
+ public SynchronizationLockException();
|
|
+ public SynchronizationLockException(string message);
|
|
+ public SynchronizationLockException(string message, Exception innerException);
|
|
+ }
|
|
+ public sealed class Thread {
|
|
+ public Thread(ParameterizedThreadStart start);
|
|
+ public Thread(ThreadStart start);
|
|
+ public CultureInfo CurrentCulture { get; set; }
|
|
+ public static Thread CurrentThread { get; }
|
|
+ public CultureInfo CurrentUICulture { get; set; }
|
|
+ public bool IsAlive { get; }
|
|
+ public bool IsBackground { get; set; }
|
|
+ public int ManagedThreadId { get; }
|
|
+ public string Name { get; set; }
|
|
+ public ThreadState ThreadState { get; }
|
|
+ ~Thread();
|
|
+ public static AppDomain GetDomain();
|
|
+ public override int GetHashCode();
|
|
+ public void Join();
|
|
+ public bool Join(int millisecondsTimeout);
|
|
+ [MethodImpl(InternalCall)]public static void MemoryBarrier();
|
|
+ public static void Sleep(int millisecondsTimeout);
|
|
+ public static void Sleep(TimeSpan timeout);
|
|
+ public static void SpinWait(int iterations);
|
|
+ public void Start();
|
|
+ public void Start(object parameter);
|
|
+ }
|
|
+ public sealed class ThreadAbortException : SystemException
|
|
+ public static class ThreadingAclExtensions {
|
|
+ public static EventWaitHandleSecurity GetAccessControl(this EventWaitHandle handle);
|
|
+ public static MutexSecurity GetAccessControl(this Mutex mutex);
|
|
+ public static SemaphoreSecurity GetAccessControl(this Semaphore semaphore);
|
|
+ public static void SetAccessControl(this EventWaitHandle handle, EventWaitHandleSecurity eventSecurity);
|
|
+ public static void SetAccessControl(this Mutex mutex, MutexSecurity mutexSecurity);
|
|
+ public static void SetAccessControl(this Semaphore semaphore, SemaphoreSecurity semaphoreSecurity);
|
|
+ }
|
|
+ public class ThreadLocal<T> : IDisposable {
|
|
+ public ThreadLocal();
|
|
+ public ThreadLocal(bool trackAllValues);
|
|
+ public ThreadLocal(Func<T> valueFactory);
|
|
+ public ThreadLocal(Func<T> valueFactory, bool trackAllValues);
|
|
+ public bool IsValueCreated { get; }
|
|
+ public T Value { get; set; }
|
|
+ public IList<T> Values { get; }
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool disposing);
|
|
+ ~ThreadLocal();
|
|
+ public override string ToString();
|
|
+ }
|
|
+ public static class ThreadPool {
|
|
+ public static bool BindHandle(SafeHandle osHandle);
|
|
+ public static void GetMaxThreads(out int workerThreads, out int completionPortThreads);
|
|
+ public static void GetMinThreads(out int workerThreads, out int completionPortThreads);
|
|
+ public static bool QueueUserWorkItem(WaitCallback callBack);
|
|
+ public static bool QueueUserWorkItem(WaitCallback callBack, object state);
|
|
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce);
|
|
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce);
|
|
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, TimeSpan timeout, bool executeOnlyOnce);
|
|
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce);
|
|
+ public static bool SetMaxThreads(int workerThreads, int completionPortThreads);
|
|
+ public static bool SetMinThreads(int workerThreads, int completionPortThreads);
|
|
+ }
|
|
+ public sealed class ThreadPoolBoundHandle : IDisposable {
|
|
+ public SafeHandle Handle { get; }
|
|
+ public unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData);
|
|
+ public unsafe NativeOverlapped* AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated);
|
|
+ public static ThreadPoolBoundHandle BindHandle(SafeHandle handle);
|
|
+ public void Dispose();
|
|
+ public unsafe void FreeNativeOverlapped(NativeOverlapped* overlapped);
|
|
+ public unsafe static object GetNativeOverlappedState(NativeOverlapped* overlapped);
|
|
+ }
|
|
+ public delegate void ThreadStart();
|
|
+ public sealed class ThreadStartException : Exception
|
|
+ public enum ThreadState {
|
|
+ Aborted = 256,
|
|
+ AbortRequested = 128,
|
|
+ Background = 4,
|
|
+ Running = 0,
|
|
+ Stopped = 16,
|
|
+ StopRequested = 1,
|
|
+ Suspended = 64,
|
|
+ SuspendRequested = 2,
|
|
+ Unstarted = 8,
|
|
+ WaitSleepJoin = 32,
|
|
+ }
|
|
+ public class ThreadStateException : Exception {
|
|
+ public ThreadStateException();
|
|
+ public ThreadStateException(string message);
|
|
+ public ThreadStateException(string message, Exception innerException);
|
|
+ }
|
|
+ public static class Timeout {
|
|
+ public const int Infinite = -1;
|
|
+ public static readonly TimeSpan InfiniteTimeSpan;
|
|
+ }
|
|
+ public sealed class Timer : IDisposable {
|
|
+ [MethodImpl(NoInlining)]public Timer(TimerCallback callback);
|
|
+ public Timer(TimerCallback callback, object state, int dueTime, int period);
|
|
+ [MethodImpl(NoInlining)]public Timer(TimerCallback callback, object state, long dueTime, long period);
|
|
+ public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period);
|
|
+ [MethodImpl(NoInlining)]public Timer(TimerCallback callback, object state, uint dueTime, uint period);
|
|
+ public bool Change(int dueTime, int period);
|
|
+ public bool Change(long dueTime, long period);
|
|
+ public bool Change(TimeSpan dueTime, TimeSpan period);
|
|
+ public bool Change(uint dueTime, uint period);
|
|
+ public void Dispose();
|
|
+ public bool Dispose(WaitHandle notifyObject);
|
|
+ }
|
|
+ public delegate void TimerCallback(object state);
|
|
+ public static class Volatile {
|
|
+ public static bool Read(ref bool location);
|
|
+ public static byte Read(ref byte location);
|
|
+ public static double Read(ref double location);
|
|
+ public static short Read(ref short location);
|
|
+ public static int Read(ref int location);
|
|
+ public static long Read(ref long location);
|
|
+ public static IntPtr Read(ref IntPtr location);
|
|
+ public static sbyte Read(ref sbyte location);
|
|
+ public static float Read(ref float location);
|
|
+ public static ushort Read(ref ushort location);
|
|
+ public static uint Read(ref uint location);
|
|
+ public static ulong Read(ref ulong location);
|
|
+ public static UIntPtr Read(ref UIntPtr location);
|
|
+ public static T Read<T>(ref T location) where T : class;
|
|
+ public static void Write(ref bool location, bool value);
|
|
+ public static void Write(ref byte location, byte value);
|
|
+ public static void Write(ref double location, double value);
|
|
+ public static void Write(ref short location, short value);
|
|
+ public static void Write(ref int location, int value);
|
|
+ public static void Write(ref long location, long value);
|
|
+ public static void Write(ref IntPtr location, IntPtr value);
|
|
+ public static void Write(ref sbyte location, sbyte value);
|
|
+ public static void Write(ref float location, float value);
|
|
+ public static void Write(ref ushort location, ushort value);
|
|
+ public static void Write(ref uint location, uint value);
|
|
+ public static void Write(ref ulong location, ulong value);
|
|
+ public static void Write(ref UIntPtr location, UIntPtr value);
|
|
+ public static void Write<T>(ref T location, T value) where T : class;
|
|
+ }
|
|
+ public delegate void WaitCallback(object state);
|
|
+ public abstract class WaitHandle : IDisposable {
|
|
+ public const int WaitTimeout = 258;
|
|
+ protected static readonly IntPtr InvalidHandle;
|
|
+ protected WaitHandle();
|
|
+ public SafeWaitHandle SafeWaitHandle { get; set; }
|
|
+ public virtual void Close();
|
|
+ public void Dispose();
|
|
+ protected virtual void Dispose(bool explicitDisposing);
|
|
+ public static bool WaitAll(WaitHandle[] waitHandles);
|
|
+ public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout);
|
|
+ public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout);
|
|
+ public static int WaitAny(WaitHandle[] waitHandles);
|
|
+ public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout);
|
|
+ public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout);
|
|
+ public virtual bool WaitOne();
|
|
+ public virtual bool WaitOne(int millisecondsTimeout);
|
|
+ public virtual bool WaitOne(TimeSpan timeout);
|
|
+ }
|
|
+ public class WaitHandleCannotBeOpenedException : Exception {
|
|
+ public WaitHandleCannotBeOpenedException();
|
|
+ public WaitHandleCannotBeOpenedException(string message);
|
|
+ public WaitHandleCannotBeOpenedException(string message, Exception innerException);
|
|
+ }
|
|
+ public static class WaitHandleExtensions {
|
|
+ public static SafeWaitHandle GetSafeWaitHandle(this WaitHandle waitHandle);
|
|
+ public static void SetSafeWaitHandle(this WaitHandle waitHandle, SafeWaitHandle value);
|
|
+ }
|
|
+ public delegate void WaitOrTimerCallback(object state, bool timedOut);
|
|
+}
|
|
```
|
|
|