Microsoft.VisualStudio.Threading Namespace

An asynchronous implementation of an AutoResetEvent.

An asynchronous barrier that blocks the signaler until all other participants have signaled.

An asynchronous style countdown event.

A mutex that can be entered asynchronously.

A thread-safe, lazily and asynchronously evaluated value factory.

Lazily executes a delegate that has some side effect (typically initializing something) such that the delegate runs at most once.

Stores references such that they are available for retrieval in the same call context.

A flavor of ManualResetEvent that can be asynchronously awaited on.

A thread-safe, asynchronously dequeuable queue.

A non-blocking lock that allows concurrent access, exclusive access, or concurrent with upgradeability to exclusive access.

Manages asynchronous access to a lock.

A non-blocking lock that allows concurrent access, exclusive access, or concurrent with upgradeability to exclusive access, making special allowances for resources that must be prepared for concurrent or exclusive access.

An asynchronous SemaphoreSlim like class with more convenient release syntax.

Extension methods and awaitables for .NET 4.5.

Extensions to CancellationToken.

A JoinableTaskFactory base class for derived types that delegate some of their work to an existing instance.

Extension methods for the WPF Dispatcher for better interop with the JoinableTaskFactory.

A contribution to an aggregate hang report.

Exception which is thrown when the contract of a ReentrantSemaphore is violated.

Tracks asynchronous operations and provides the ability to Join those operations to avoid deadlocks while synchronously blocking the Main thread for the operation's completion.

Tracks asynchronous operations and provides the ability to Join those operations to avoid deadlocks while synchronously blocking the Main thread for the operation's completion.

A collection of incomplete JoinableTask objects.

A common context within which joinable tasks may be created and interact to avoid deadlocks.

A class to encapsulate the details of a possible hang. An instance of this JoinableTaskContext.HangDetails class will be passed to the JoinableTaskContextNode instances who registered the hang notifications.

An exception thrown when the configuration provided to the JoinableTaskContext are incorrect or a virtual method is overridden such that it violates a contract. This exception should not be caught. It is thrown when the application has a programming fault.

A customizable source of JoinableTaskFactory instances.

A factory for starting asynchronous tasks that can mitigate deadlocks when the tasks require the Main thread of an application and the Main thread may itself be blocking on the completion of a task.

A SynchronizationContext whose synchronously blocking Wait method does not allow any reentrancy via the message pump.

A SynchronizationContext that executes messages in the order they are received.

An incremental progress reporting mechanism that also allows asynchronous awaiting for all reports to be processed.

A JoinableTaskFactory-aware semaphore that allows reentrancy without consuming another slot in the semaphore.

Exception thrown when a ReentrantSemaphore is in a faulted state.

A single-threaded synchronization context, akin to the DispatcherSynchronizationContext and WindowsFormsSynchronizationContext.

A message pumping frame that may be pushed with PushFrame(SingleThreadedSynchronizationContext+Frame) to pump messages on the owning thread.

Utility methods for working across threads.

Extensions to the Task Parallel Library.

The value returned from EnterAsync(TimeSpan) that must be disposed to release the mutex.

A structure that hides relevance of a block of code from a particular AsyncLazy<T> and the JoinableTaskContext it was created with.

An awaitable that is returned from asynchronous lock requests.

A "public" representation of a specific lock.

A value whose disposal releases a held lock.

A value whose disposal restores visibility of any locks held by the caller.

An awaitable that is returned from asynchronous lock requests.

Manages asynchronous access to a lock.

A value whose disposal releases a held lock.

A value whose disposal triggers the release of a lock.

The result of ConfigureAwaitForAggregateException(Task, Boolean) to prepare a Task to be awaited while throwing with all inner exceptions.

The result of GetAwaiter() to prepare a Task to be awaited while throwing with all inner exceptions.

An awaitable that will always lead the calling async method to yield, then immediately resume, possibly on the original SynchronizationContext.

An awaiter that will always lead the calling async method to yield, then immediately resume, possibly on the original SynchronizationContext.

A Task awaitable that has affinity to executing callbacks synchronously on the completing callstack.

A Task awaitable that has affinity to executing callbacks synchronously on the completing callstack.

A Task awaiter that has affinity to executing callbacks synchronously on the completing callstack.

A Task awaiter that has affinity to executing callbacks synchronously on the completing callstack.

An awaiter returned from GetAwaiter(SynchronizationContext).

An awaitable that executes continuations on the specified task scheduler.

An awaiter returned from GetAwaiter(TaskScheduler).

Provides access to a CancellationToken that combines multiple other tokens, and allows convenient disposal of any applicable CancellationTokenSource.

A value whose disposal cancels a Join() operation.

A structure that clears CallContext and SynchronizationContext async/thread statics and restores those values when this structure is disposed.

An awaitable struct that facilitates an asynchronous transition to the Main thread.

An awaiter struct that facilitates an asynchronous transition to the Main thread.

A structure that hides any evidence that the caller has entered a ReentrantSemaphore till this value is disposed.

A structure that applies and reverts changes to the SynchronizationContext.

An awaitable that wraps a task and never throws an exception when waited on.

An awaiter that wraps a task and never throws an exception when waited on.

An awaitable that wraps a task and never throws an exception when waited on.

An awaitable that wraps a ValueTask<TResult> and never throws an exception when waited on.

An awaiter that wraps a task and never throws an exception when waited on.

An awaiter that wraps a task and never throws an exception when waited on.

Defines an asynchronous method to release allocated resources.

Provides a facility to produce reports that may be useful when analyzing hangs.

Flags that modify default lock behavior.

Flags that modify default lock behavior.

Specifies flags that control optional behavior for the creation and execution of tasks.

Describes ways the ReentrantSemaphore may behave when a semaphore request is made in a context that is already in the semaphore.

The various types of data within a registry key that generate notifications when changed.

An asynchronous event handler.

An asynchronous event handler.