Microsoft.VisualStudio.Threading Namespace

The Microsoft.VisualStudio.Threading namespace contains APIs for use in Visual Studio SDK projects. You should use these APIs for asynchronous programming in Visual Studio. Doing so helps you avoid deadlocks

This library is based on the .NET Framework Task Parallel Library (TPL). For information about this library, see Task Parallel Library (TPL).

Classes

AsyncAutoResetEvent

An asynchronous implementation of an AutoResetEvent.

AsyncBarrier

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

AsyncCountdownEvent

An asynchronous style countdown event.

AsyncLazy<T>

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

AsyncLazyInitializer

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

AsyncLocal<T>

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

AsyncManualResetEvent

A flavor of ManualResetEvent that can be asynchronously awaited on.

AsyncQueue<T>

A thread-safe, asynchronously dequeuable queue.

AsyncReaderWriterLock

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

AsyncReaderWriterLock.Awaiter

Manages asynchronous access to a lock.

AsyncReaderWriterResourceLock<TMoniker,TResource>

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.

AsyncSemaphore

An asynchronous SemaphoreSlim like class with more convenient release syntax.

AwaitExtensions

Extension methods and awaitables for .NET 4.5.

CancellationTokenExtensions

Extensions to CancellationToken.

DelegatingJoinableTaskFactory

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

DispatcherExtensions

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

HangReportContribution

A contribution to an aggregate hang report.

JoinableTask

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.

JoinableTask<T>

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.

JoinableTaskCollection

A collection of joinable tasks.

JoinableTaskContext

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

JoinableTaskContext.HangDetails

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.

JoinableTaskContextException

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.

JoinableTaskContextNode

A customizable source of JoinableTaskFactory instances.

JoinableTaskFactory

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.

NoMessagePumpSyncContext

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

ProgressWithCompletion<T>

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

ReentrantSemaphore

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

SingleThreadedSynchronizationContext

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

SingleThreadedSynchronizationContext.Frame

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

ThreadingTools

Utility methods for working across threads.

TplExtensions

Extensions to the Task Parallel Library.

Structs

AsyncReaderWriterLock.Awaitable

An awaitable that is returned from asynchronous lock requests.

AsyncReaderWriterLock.LockHandle

A "public" representation of a specific lock.

AsyncReaderWriterLock.Releaser

A value whose disposal releases a held lock.

AsyncReaderWriterLock.Suppression

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

AsyncReaderWriterResourceLock<TMoniker,TResource>.ResourceAwaitable

An awaitable that is returned from asynchronous lock requests.

AsyncReaderWriterResourceLock<TMoniker,TResource>.ResourceAwaiter

Manages asynchronous access to a lock.

AsyncReaderWriterResourceLock<TMoniker,TResource>.ResourceReleaser

A value whose disposal releases a held lock.

AsyncSemaphore.Releaser

A value whose disposal triggers the release of a lock.

AwaitExtensions.ConfiguredTaskYieldAwaitable

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

AwaitExtensions.ConfiguredTaskYieldAwaiter

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

AwaitExtensions.ExecuteContinuationSynchronouslyAwaitable

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

AwaitExtensions.ExecuteContinuationSynchronouslyAwaitable<T>

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

AwaitExtensions.ExecuteContinuationSynchronouslyAwaiter

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

AwaitExtensions.ExecuteContinuationSynchronouslyAwaiter<T>

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

AwaitExtensions.TaskSchedulerAwaitable

An awaitable that executes continuations on the specified task scheduler.

AwaitExtensions.TaskSchedulerAwaiter

An awaiter returned from GetAwaiter(TaskScheduler).

CancellationTokenExtensions.CombinedCancellationToken

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

JoinableTaskCollection.JoinRelease

A value whose disposal cancels a Join() operation.

JoinableTaskContext.RevertRelevance

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

JoinableTaskFactory.MainThreadAwaitable

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

JoinableTaskFactory.MainThreadAwaiter

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

ReentrantSemaphore.RevertRelevance

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

SpecializedSyncContext

A structure that applies and reverts changes to the SynchronizationContext.

TplExtensions.NoThrowTaskAwaitable

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

TplExtensions.NoThrowTaskAwaiter

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

Interfaces

IAsyncDisposable

Defines an asynchronous method to release allocated resources.

IHangReportContributor

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

Enums

AsyncReaderWriterLock.LockFlags

Flags that modify default lock behavior.

AsyncReaderWriterResourceLock<TMoniker,TResource>.LockFlags

Flags that modify default lock behavior.

JoinableTaskCreationOptions

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

ReentrantSemaphore.ReentrancyMode

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

RegistryChangeNotificationFilters

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

Delegates

AsyncEventHandler

An asynchronous event handler.

AsyncEventHandler<T>

An asynchronous event handler.