WaitHandle

System\Diagnostics\ProcessWaitHandle.Unix.cs (1)

9internal sealed class ProcessWaitHandle : WaitHandle

System\DirectoryServices\Protocols\ldap\LdapAsyncResult.cs (1)

46private sealed class LdapAsyncWaitHandle : WaitHandle

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipe.cs (1)

80internal sealed class EventPipeWaitHandle : WaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\EventWaitHandle.cs (1)

11public partial class EventWaitHandle : WaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\Mutex.cs (1)

14public sealed partial class Mutex : WaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\Semaphore.cs (1)

11public sealed partial class Semaphore : WaitHandle

src\System\Threading\Mutex.CoreCLR.Unix.cs (1)

15public sealed partial class Mutex : WaitHandle

FrameworkFork\System.ServiceModel\Internals\System\Runtime\AsyncResult.cs (1)

49public WaitHandle AsyncWaitHandle

FrameworkFork\System.ServiceModel\Internals\System\Runtime\TimeoutHelper.cs (1)

210public static bool WaitOne(WaitHandle waitHandle, TimeSpan timeout)

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

RequestProcessing\ClientCertLoader.cs (1)

331public WaitHandle AsyncWaitHandle

RequestProcessing\RequestStreamAsyncResult.cs (1)

162public WaitHandle AsyncWaitHandle

RequestProcessing\ResponseStreamAsyncResult.cs (1)

318public WaitHandle AsyncWaitHandle

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\Shared\TaskToApm.cs (2)

116/// <summary>Gets a <see cref="WaitHandle"/> that is used to wait for an asynchronous operation to complete.</summary> 117public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

AwaitExtensions.cs (12)

52/// Provides await functionality for ordinary <see cref="WaitHandle"/>s. 56internal static TaskAwaiter GetAwaiter(this WaitHandle handle) 63/// Provides await functionality for an array of ordinary <see cref="WaitHandle"/>s. 67internal static TaskAwaiter<int> GetAwaiter(this WaitHandle[] handles) 74/// Creates a TPL Task that is marked as completed when a <see cref="WaitHandle"/> is signaled. 82internal static Task ToTask(this WaitHandle handle, int timeout = Timeout.Infinite) 84return ToTask(new WaitHandle[1] { handle }, timeout); 88/// Creates a TPL Task that is marked as completed when any <see cref="WaitHandle"/> in the array is signaled. 96internal static Task<int> ToTask(this WaitHandle[] handles, int timeout = Timeout.Infinite) 101int signalledHandle = WaitHandle.WaitAny(handles, 0); 102if (signalledHandle != WaitHandle.WaitTimeout) 123tcs.TrySetResult(WaitHandle.WaitTimeout);

BackEnd\BuildManager\BuildSubmission.cs (1)

263public new WaitHandle WaitHandle => base.WaitHandle;

BackEnd\BuildManager\BuildSubmissionBase.cs (2)

64/// A <see cref="System.Threading.WaitHandle"/> which will be signalled when the build is complete. Valid after <see cref="BuildSubmissionBase{TRequestData,TResultData}.Execute()"/> or <see cref="BuildSubmission.ExecuteAsync(BuildSubmissionCompleteCallback, object)"/> returns, otherwise null. 66public WaitHandle WaitHandle => CompletionEvent;

BackEnd\BuildManager\LegacyThreadingData.cs (1)

121internal WaitHandle GetStartRequestBuilderMainThreadEventForSubmission(int submissionId)

BackEnd\Client\MSBuildClient.cs (2)

315WaitHandle[] waitHandles = 324int index = WaitHandle.WaitAny(waitHandles);

BackEnd\Client\MSBuildClientPacketPump.cs (2)

217WaitHandle[] handles = 230int waitId = WaitHandle.WaitAny(handles);

BackEnd\Components\Communications\NodeEndpointInProc.cs (2)

431WaitHandle[] handles = [_terminatePacketPump, _packetAvailable]; 436int waitId = WaitHandle.WaitAny(handles);

BackEnd\Components\Logging\LoggingService.cs (2)

1378WaitHandle[] waitHandlesForNextEvent = [completeAdding.WaitHandle, _enqueueEvent]; 1402WaitHandle.WaitAny(waitHandlesForNextEvent);

BackEnd\Components\RequestBuilder\RequestBuilder.cs (12)

406WaitHandle[] handles = [_terminateEvent, _continueEvent]; 411handle = WaitHandle.WaitAny(handles); 452WaitHandle[] handles = [_terminateEvent, _continueEvent]; 454int handle = WaitHandle.WaitAny(handles); 510WaitHandle[] waitHandles = [_terminateEvent, responseEvent]; 517waitResult = WaitHandle.WaitAny(waitHandles); 582internal static int WaitWithBuilderThreadStart(WaitHandle[] handles, bool recursive, LegacyThreadingData threadingData, int submissionId) 584WaitHandle[] allHandles = new WaitHandle[handles.Length + 1]; 592int signaledIndex = WaitHandle.WaitAny(allHandles, Timeout.Infinite); 963WaitHandle[] handles = [_terminateEvent, _continueEvent]; 982handle = WaitHandle.WaitAny(handles);

BackEnd\Components\SdkResolution\OutOfProcNodeSdkResolverService.cs (1)

134WaitHandle.WaitAny([_responseReceivedEvent, ShutdownEvent]);

BackEnd\Node\InProcNode.cs (2)

145WaitHandle[] waitHandles = [_shutdownEvent, _packetReceivedEvent]; 151int index = WaitHandle.WaitAny(waitHandles);

BackEnd\Node\OutOfProcNode.cs (2)

257WaitHandle[] waitHandles = [_shutdownEvent, _packetReceivedEvent]; 262int index = WaitHandle.WaitAny(waitHandles);

BackEnd\Node\OutOfProcServerNode.cs (2)

135WaitHandle[] waitHandles = [_shutdownEvent, _packetReceivedEvent]; 140int index = WaitHandle.WaitAny(waitHandles);

Graph\GraphBuildSubmission.cs (1)

94public new WaitHandle WaitHandle => base.WaitHandle;

NodeEndpointOutOfProcBase.cs (3)

628WaitHandle[] handles = new WaitHandle[] 642int waitId = WaitHandle.WaitAny(handles);

BackEnd\BuildRequestEngine_Tests.cs (8)

122WaitHandle[] handles = new WaitHandle[2] { _cancelEvent, _continueEvent }; 123int evt = WaitHandle.WaitAny(handles, 5000); 525private void WaitForEvent(WaitHandle evt, string eventName) 527WaitHandle[] events = new WaitHandle[2] { _engineExceptionEvent, evt }; 528int index = WaitHandle.WaitAny(events, 5000); 529if (WaitHandle.WaitTimeout == index)

BackEnd\NodeEndpointInProc_Tests.cs (1)

124public WaitHandle DataReceivedEvent

BackEnd\RequestBuilder_Tests.cs (1)

326private void WaitForEvent(WaitHandle evt, string eventName)

ToolTask.cs (2)

889WaitHandle[] notifications = 918int notificationIndex = WaitHandle.WaitAny(notifications);

AsyncTask.cs (3)

274 WaitHandle[] handles = new WaitHandle[] { 286 var index = (WaitHandleIndex)System.Threading.WaitHandle.WaitAny(handles, TimeSpan.FromMilliseconds(10));

NodeEndpointOutOfProcBase.cs (3)

628WaitHandle[] handles = new WaitHandle[] 642int waitId = WaitHandle.WaitAny(handles);

OutOfProcTaskHostNode.cs (2)

662WaitHandle[] waitHandles = [_shutdownEvent, _packetReceivedEvent, _taskCompleteEvent, _taskCancelledEvent]; 666int index = WaitHandle.WaitAny(waitHandles);

NodeEndpointOutOfProcBase.cs (3)

628WaitHandle[] handles = new WaitHandle[] 642int waitId = WaitHandle.WaitAny(handles);

OutOfProcTaskHostNode.cs (2)

662WaitHandle[] waitHandles = [_shutdownEvent, _packetReceivedEvent, _taskCompleteEvent, _taskCancelledEvent]; 666int index = WaitHandle.WaitAny(waitHandles);

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

1188[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.WaitHandle))]

netstandard.cs (1)

2151[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.WaitHandle))]

MS\Internal\IO\Packaging\NetStream.cs (1)

1080int index = WaitHandle.WaitAny(_readEventHandles);

System\Windows\Documents\PageContentAsyncResult.cs (1)

87public WaitHandle AsyncWaitHandle

System\Collections\Concurrent\BlockingCollection.cs (11)

971List<WaitHandle> handles = GetHandles(collections, externalCancellationToken, true, out collatedCancellationTokens); 987index = WaitHandle.WaitAny(handles.ToArray(), timeout); 998Debug.Assert((index == WaitHandle.WaitTimeout) || (index >= 0 && index < handles.Count)); 1000if (index == WaitHandle.WaitTimeout) //case#2 1048private static List<WaitHandle> GetHandles(BlockingCollection<T>[] collections, CancellationToken externalCancellationToken, bool isAddOperation, out CancellationToken[] cancellationTokens) 1051List<WaitHandle> handlesList = new List<WaitHandle>(collections.Length + 1); // + 1 for the external token handle to be added 1375List<WaitHandle> handles = GetHandles(collections, externalCancellationToken, false, out collatedCancellationTokens); 1387int index = WaitHandle.WaitAny(handles.ToArray(), timeout); 1396Debug.Assert((index == WaitHandle.WaitTimeout) || (index >= 0 && index < handles.Count)); 1397if (index == WaitHandle.WaitTimeout) //case#2

Common\System\Data\ProviderBase\DbConnectionPool.cs (9)

47private readonly WaitHandle[] _handlesWithCreate; 48private readonly WaitHandle[] _handlesWithoutCreate; 56_handlesWithCreate = new WaitHandle[] { _poolSemaphore, _errorEvent, _creationSemaphore }; 57_handlesWithoutCreate = new WaitHandle[] { _poolSemaphore, _errorEvent }; 76internal WaitHandle[] GetHandles(bool withCreate) 733waitResult = WaitHandle.WaitAny(_waitHandles.GetHandles(allowCreate), unchecked((int)waitForMultipleObjectsTimeout)); 744case WaitHandle.WaitTimeout: 963waitResult = WaitHandle.WaitAny(_waitHandles.GetHandles(withCreate: true), CreationTimeout); 990else if (WaitHandle.WaitTimeout == waitResult)

System\Diagnostics\Process.cs (2)

65private WaitHandle? _waitHandle; 1366WaitHandle? wh = null;

System\DirectoryServices\Protocols\ldap\LdapAsyncResult.cs (1)

28WaitHandle IAsyncResult.AsyncWaitHandle => field ??= new LdapAsyncWaitHandle(_manualResetEvent.SafeWaitHandle);

src\libraries\Common\src\System\Net\LazyAsyncResult.cs (1)

89public WaitHandle AsyncWaitHandle

System\Net\Managed\HttpStreamAsyncResult.cs (1)

84public WaitHandle AsyncWaitHandle

System\Net\Managed\ListenerAsyncResult.Managed.cs (1)

212public WaitHandle AsyncWaitHandle

src\libraries\Common\src\System\Net\LazyAsyncResult.cs (1)

89public WaitHandle AsyncWaitHandle

System\Net\TimerThread.cs (4)

91private static readonly WaitHandle[] s_threadEvents = { s_threadShutdownEvent, s_threadReadyEvent }; 555int waitResult = WaitHandle.WaitAny(s_threadEvents, waitDuration, false); 565if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, $"Awoke, cause {(waitResult == WaitHandle.WaitTimeout ? "Timeout" : "Prod")}"); 568if (waitResult == WaitHandle.WaitTimeout && !haveNextTick)

src\libraries\Common\src\System\Threading\Tasks\TaskToAsyncResult.cs (1)

155public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

src\libraries\System.Private.CoreLib\src\System\GC.cs (2)

17=> WaitForFullGCApproach(WaitHandle.ToTimeoutMilliseconds(timeout)); 26=> WaitForFullGCComplete(WaitHandle.ToTimeoutMilliseconds(timeout));

src\libraries\System.Private.CoreLib\src\System\IAsyncResult.cs (1)

15WaitHandle AsyncWaitHandle { get; }

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (1)

197protected virtual WaitHandle CreateWaitHandle() => new ManualResetEvent(false);

src\libraries\System.Private.CoreLib\src\System\Threading\AbandonedMutexException.cs (4)

35public AbandonedMutexException(int location, WaitHandle? handle) 42public AbandonedMutexException(string? message, int location, WaitHandle? handle) 49public AbandonedMutexException(string? message, Exception? inner, int location, WaitHandle? handle) 63private void SetupException(int location, WaitHandle? handle)

src\libraries\System.Private.CoreLib\src\System\Threading\CancellationToken.cs (3)

78/// Gets a <see cref="Threading.WaitHandle"/> that is signaled when the token is canceled.</summary> 80/// Accessing this property causes a <see cref="Threading.WaitHandle">WaitHandle</see> 87public WaitHandle WaitHandle => (_source ?? CancellationTokenSource.s_neverCanceledSource).WaitHandle;

src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (2)

44/// <summary><see cref="Threading.WaitHandle"/> lazily initialized and returned from <see cref="WaitHandle"/>.</summary> 90internal WaitHandle WaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\Lock.cs (1)

239public bool TryEnter(TimeSpan timeout) => TryEnter_Outlined(WaitHandle.ToTimeoutMilliseconds(timeout));

src\libraries\System.Private.CoreLib\src\System\Threading\ManualResetEventSlim.cs (3)

67/// Gets the underlying <see cref="Threading.WaitHandle"/> object for this <see 70/// <value>The underlying <see cref="Threading.WaitHandle"/> event object fore this <see 77public WaitHandle WaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\Monitor.cs (4)

14=> TryEnter(obj, WaitHandle.ToTimeoutMilliseconds(timeout)); 17=> TryEnter(obj, WaitHandle.ToTimeoutMilliseconds(timeout), ref lockTaken); 22public static bool Wait(object obj, TimeSpan timeout) => Wait(obj, WaitHandle.ToTimeoutMilliseconds(timeout)); 41=> Wait(obj, WaitHandle.ToTimeoutMilliseconds(timeout));

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.cs (1)

483WaitHandle waitObject,

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WaitThread.cs (13)

151private readonly RegisteredWaitHandle[] _registeredWaits = new RegisteredWaitHandle[WaitHandle.MaxWaitHandles - 1]; 158private readonly SafeWaitHandle[] _waitHandles = new SafeWaitHandle[WaitHandle.MaxWaitHandles]; 167private readonly RegisteredWaitHandle?[] _pendingRemoves = new RegisteredWaitHandle[WaitHandle.MaxWaitHandles - 1]; 244int signaledHandleIndex = WaitHandle.WaitAny(new ReadOnlySpan<SafeWaitHandle>(_waitHandles, 0, numUserWaits + 1), timeoutDurationMs); 246if (signaledHandleIndex >= WaitHandle.WaitAbandoned && 247signaledHandleIndex < WaitHandle.WaitAbandoned + 1 + numUserWaits) 250Debug.Assert(signaledHandleIndex != WaitHandle.WaitAbandoned); // the first wait handle is an event 251signaledHandleIndex += WaitHandle.WaitSuccess - WaitHandle.WaitAbandoned; 259if (signaledHandleIndex != WaitHandle.WaitTimeout) 398if (_numUserWaits == WaitHandle.MaxWaitHandles - 1) 422/// As per CoreCLR's behavior, if the user passes in an invalid <see cref="WaitHandle"/> 423/// into <see cref="RegisteredWaitHandle.Unregister(WaitHandle)"/>, then the unregistration of the wait handle is blocking.

src\libraries\System.Private.CoreLib\src\System\Threading\RegisteredWaitHandle.Portable.cs (5)

11/// An object representing the registration of a <see cref="WaitHandle"/> via <see cref="ThreadPool.RegisterWaitForSingleObject"/>. 22/// The <see cref="WaitHandle"/> the user passed in via <see cref="Unregister(WaitHandle)"/>. 55internal RegisteredWaitHandle(WaitHandle waitHandle, _ThreadPoolWaitOrTimerCallback callbackHelper, 95private bool UnregisterPortableCore(WaitHandle waitObject)

src\libraries\System.Private.CoreLib\src\System\Threading\RegisteredWaitHandle.Unix.cs (2)

11/// An object representing the registration of a <see cref="WaitHandle"/> via <see cref="ThreadPool.RegisterWaitForSingleObject"/>. 60public bool Unregister(WaitHandle waitObject) => UnregisterPortableCore(waitObject);

src\libraries\System.Private.CoreLib\src\System\Threading\SemaphoreSlim.cs (4)

85/// Returns a <see cref="WaitHandle"/> that can be used to wait on the semaphore. 87/// <value>A <see cref="WaitHandle"/> that can be used to wait on the 97public WaitHandle AvailableWaitHandle 963WaitHandle? wh = m_waitHandle;

src\libraries\System.Private.CoreLib\src\System\Threading\SynchronizationContext.cs (1)

52return WaitHandle.WaitMultipleIgnoringSyncContext(waitHandles, waitAll, millisecondsTimeout);

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (2)

1412/// Gets a <see cref="WaitHandle"/> that can be used to wait for the task to 1423WaitHandle IAsyncResult.AsyncWaitHandle

src\libraries\System.Private.CoreLib\src\System\Threading\Thread.cs (2)

569public bool Join(TimeSpan timeout) => Join(WaitHandle.ToTimeoutMilliseconds(timeout)); 571public static void Sleep(TimeSpan timeout) => Sleep(WaitHandle.ToTimeoutMilliseconds(timeout));

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPool.Unix.cs (1)

81WaitHandle waitObject,

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (8)

1681WaitHandle waitObject, 1701WaitHandle waitObject, 1720WaitHandle waitObject, 1735WaitHandle waitObject, 1753WaitHandle waitObject, 1772WaitHandle waitObject, 1791WaitHandle waitObject, 1813WaitHandle waitObject,

src\libraries\System.Private.CoreLib\src\System\Threading\Timer.cs (6)

574public bool Dispose(WaitHandle toSignal) 612if (notifyWhenNoCallbacksRunning is WaitHandle) 693Debug.Assert(toSignal is WaitHandle || toSignal is Task); 695if (toSignal is WaitHandle wh) 799public bool Dispose(WaitHandle notifyObject) 949public bool Dispose(WaitHandle notifyObject)

src\libraries\System.Private.CoreLib\src\System\Threading\WaitHandle.cs (24)

src\libraries\System.Private.CoreLib\src\System\Threading\WaitHandleExtensions.cs (4)

13/// <param name="waitHandle">The <see cref="WaitHandle"/> to operate on.</param> 15public static SafeWaitHandle GetSafeWaitHandle(this WaitHandle waitHandle) 25/// <param name="waitHandle">The <see cref="WaitHandle"/> to operate on.</param> 27public static void SetSafeWaitHandle(this WaitHandle waitHandle, SafeWaitHandle? value)

src\System\Threading\LowLevelLifoSemaphore.Unix.cs (3)

30Debug.Assert(waitResult == WaitHandle.WaitSuccess || waitResult == WaitHandle.WaitTimeout); 31return waitResult == WaitHandle.WaitSuccess;

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

847[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.WaitHandle))]

System\Runtime\OperationWithTimeoutAsyncResult.cs (1)

77public WaitHandle AsyncWaitHandle

Internals\System\Runtime\AsyncResult.cs (1)

39public WaitHandle AsyncWaitHandle

Internals\System\Runtime\IOThreadTimer.cs (1)

652WaitHandle.WaitAny(waitableTimers, (int)waitDurationInMillis);

Internals\System\Runtime\TimeoutHelper.cs (1)

207public static bool WaitOne(WaitHandle waitHandle, TimeSpan timeout)

System\Threading\CountdownEvent.cs (3)

108/// Gets a <see cref="System.Threading.WaitHandle"/> that is used to wait for the event to be set. 110/// <value>A <see cref="System.Threading.WaitHandle"/> that is used to wait for the event to be set.</value> 117public WaitHandle WaitHandle

System\Transactions\CommittableTransaction.cs (1)

193WaitHandle IAsyncResult.AsyncWaitHandle

System\Windows\Forms\Control.cs (2)

3559private unsafe void WaitForWaitHandle(WaitHandle waitHandle) 6555using WaitHandle waitHandle = tme.AsyncWaitHandle;

System\Windows\Forms\Control.ThreadMethodEntry.cs (1)

49public WaitHandle AsyncWaitHandle

MockAsyncResult.cs (1)

28public WaitHandle AsyncWaitHandle { get; set; }

Extensions.cs (2)

19public static Task ToTask(this WaitHandle handle, int? timeoutMilliseconds) 39public static async Task WaitOneAsync(this WaitHandle handle, int? timeoutMilliseconds = null) => await handle.ToTask(timeoutMilliseconds);