System.Threading

A stub version of .NET 4.0 contracts.

A dummy class that implements GetResourceString. Environment.GetResourceString(string) is an internal method in mscorlib.dll.

An interface similar to the one added in .NET 4.0.

.NET 4.0 Monitor class supports new overloads that return a boolean value representing whether the lock was successfully taken or not. The return value is meant to be accurate even in the presence of thread aborts. Monitor2 implements these methods as simple wrappers over the .NET 3.5 methods, but without making the guarantees related to thread aborts.

This internal class from mscorlib.dll is used by ConcurrentDictionary.

OperationCanceledException is changing from .NET 3.5 to .NET 4.0. To make Parallel Extensions work, we include the new version as OperationCanceledException2.

A convenience class for common platform-related logic.

Gets the number of available processors available to this process on the current machine.

A dummy replacement for the .NET 4.0 SecuritySafeCriticalAttribute. The dummy attribute makes the code compile, but we are likely losing the ability to be called from a partial trust environment.

A dummy replacement for the .NET internal class StackCrawlMark.

Represents a thread-safe collection of keys and values.

The type of the keys in the dictionary. The type of the values in the dictionary. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initializes a new instance of the class that is empty, has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

Initializes a new instance of the class that is empty, has the specified concurrency level and capacity, and uses the default comparer for the key type.

The estimated number of threads that will update the concurrently. The initial number of elements that the can contain. is less than 1. is less than 0.

Initializes a new instance of the class that contains elements copied from the specified , has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

The whose elements are copied to the new . is a null reference (Nothing in Visual Basic). contains one or more duplicate keys.

Initializes a new instance of the class that is empty, has the specified concurrency level and capacity, and uses the specified .

The implementation to use when comparing keys. is a null reference (Nothing in Visual Basic).

Initializes a new instance of the class that contains elements copied from the specified , has the default concurrency level, has the default initial capacity, and uses the specified .

The whose elements are copied to the new . The implementation to use when comparing keys. is a null reference (Nothing in Visual Basic). -or- is a null reference (Nothing in Visual Basic).

Initializes a new instance of the class that contains elements copied from the specified , has the specified concurrency level, has the specified initial capacity, and uses the specified .

The estimated number of threads that will update the concurrently. The whose elements are copied to the new . The implementation to use when comparing keys. is a null reference (Nothing in Visual Basic). -or- is a null reference (Nothing in Visual Basic). is less than 1. contains one or more duplicate keys.

Initializes a new instance of the class that is empty, has the specified concurrency level, has the specified initial capacity, and uses the specified .

The estimated number of threads that will update the concurrently. The initial number of elements that the can contain. The implementation to use when comparing keys. is less than 1. -or- is less than 0. is a null reference (Nothing in Visual Basic).

Attempts to add the specified key and value to the .

The key of the element to add. The value of the element to add. The value can be a null reference (Nothing in Visual Basic) for reference types. true if the key/value pair was added to the successfully; otherwise, false. is null reference (Nothing in Visual Basic). The contains too many elements.

Determines whether the contains the specified key.

The key to locate in the . true if the contains an element with the specified key; otherwise, false. is a null reference (Nothing in Visual Basic).

Attempts to remove and return the the value with the specified key from the .

The key of the element to remove and return. When this method returns, contains the object removed from the or the default value of if the operation failed. true if an object was removed successfully; otherwise, false. is a null reference (Nothing in Visual Basic).

Removes the specified key from the dictionary if it exists and returns its associated value. If matchValue flag is set, the key will be removed only if is associated with a particular value.

The key to search for and remove if it exists. The variable into which the removed value, if found, is stored. Whether removal of the key is conditional on its value. The conditional value to compare against if is true

Attempts to get the value associated with the specified key from the .

The key of the value to get. When this method returns, contains the object from the with the spedified key or the default value of , if the operation failed. true if the key was found in the ; otherwise, false. is a null reference (Nothing in Visual Basic).

Compares the existing value for the specified key with a specified value, and if they’re equal, updates the key with a third value.

The key whose value is compared with and possibly replaced. The value that replaces the value of the element with if the comparison results in equality. The value that is compared to the value of the element with . true if the value with was equal to and replaced with ; otherwise, false. is a null reference.

Removes all keys and values from the .

Copies the elements of the to an array of type , starting at the specified array index.

The one-dimensional array of type that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than 0. is equal to or greater than the length of the . -or- The number of elements in the source is greater than the available space from to the end of the destination .

Copies the key and value pairs stored in the to a new array.

A new array containing a snapshot of key and value pairs copied from the .

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. Important: the caller must hold all locks in m_locks before calling CopyToPairs.

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. Important: the caller must hold all locks in m_locks before calling CopyToEntries.

Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. Important: the caller must hold all locks in m_locks before calling CopyToObjects.

Returns an enumerator that iterates through the .

An enumerator for the . The enumerator returned from the dictionary is safe to use concurrently with reads and writes to the dictionary, however it does not represent a moment-in-time snapshot of the dictionary. The contents exposed through the enumerator may contain modifications made to the dictionary after was called.

Shared internal implementation for inserts and updates. If key exists, we always return false; and if updateIfExists == true we force update with value; If key doesn't exist, we always add value and return true;

Adds a key/value pair to the if the key does not already exist.

The key of the element to add. The function used to generate a value for the key is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value for the key as returned by valueFactory if the key was not in the dictionary.

Adds a key/value pair to the if the key does not already exist.

The key of the element to add. the value to be added, if the key does not already exist is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.

Adds a key/value pair to the if the key does not already exist, or updates a key/value pair in the if the key already exists.

The key to be added or whose value should be updated The function used to generate a value for an absent key The function used to generate a new value for an existing key based on the key's existing value is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The new value for the key. This will be either be the result of addValueFactory (if the key was absent) or the result of updateValueFactory (if the key was present).

Adds a key/value pair to the if the key does not already exist, or updates a key/value pair in the if the key already exists.

The key to be added or whose value should be updated The value to be added for an absent key The function used to generate a new value for an existing key based on the key's existing value is a null reference (Nothing in Visual Basic). is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. The new value for the key. This will be either be the result of addValueFactory (if the key was absent) or the result of updateValueFactory (if the key was present).

Adds the specified key and value to the .

The object to use as the key of the element to add. The object to use as the value of the element to add. is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. An element with the same key already exists in the .

Removes the element with the specified key from the .

The key of the element to remove. true if the element is successfully remove; otherwise false. This method also returns false if was not found in the original . is a null reference (Nothing in Visual Basic).

Adds the specified value to the with the specified key.

The structure representing the key and value to add to the . The of is null. The contains too many elements. An element with the same key already exists in the

Determines whether the contains a specific key and value.

The structure to locate in the . true if the is found in the ; otherwise, false.

Removes a key and value from the dictionary.

The structure representing the key and value to remove from the . true if the key and value represented by is successfully found and removed; otherwise, false. The Key property of is a null reference (Nothing in Visual Basic).

Returns an enumerator that iterates through the .

Adds the specified key and value to the dictionary.

The object to use as the key. The object to use as the value. is a null reference (Nothing in Visual Basic). The dictionary contains too many elements. is of a type that is not assignable to the key type of the . -or- is of a type that is not assignable to , the type of values in the . -or- A value with the same key already exists in the .

Gets whether the contains an element with the specified key.

The key to locate in the . true if the contains an element with the specified key; otherwise, false. is a null reference (Nothing in Visual Basic).

Provides an for the .

An for the .

Removes the element with the specified key from the .

The key of the element to remove. is a null reference (Nothing in Visual Basic).

Copies the elements of the to an array, starting at the specified array index.

The one-dimensional array that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than 0. is equal to or greater than the length of the . -or- The number of elements in the source is greater than the available space from to the end of the destination .

Replaces the internal table with a larger one. To prevent multiple threads from resizing the table as a result of races, the table of buckets that was deemed too small is passed in as an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket table has been replaced in the meantime or not.

Reference to the bucket table that was deemed too small.

Computes the bucket and lock number for a particular key.

Acquires all locks for this hash table, and increments locksAcquired by the number of locks that were successfully acquired. The locks are acquired in an increasing order.

Acquires a contiguous range of locks for this hash table, and increments locksAcquired by the number of locks that were successfully acquired. The locks are acquired in an increasing order.

Releases a contiguous range of locks.

Gets a collection containing the keys in the dictionary.

Gets a collection containing the values in the dictionary.

A helper method for asserts.

A helper function to obtain the string for a particular resource key.

Get the data array to be serialized

Construct the dictionary from a previously seiralized one

Gets or sets the value associated with the specified key.

The key of the value to get or set. The value associated with the specified key. If the specified key is not found, a get operation throws a , and a set operation creates a new element with the specified key. is a null reference (Nothing in Visual Basic). The property is retrieved and does not exist in the collection.

Gets the number of key/value pairs contained in the .

The dictionary contains too many elements. The number of key/value paris contained in the . Count has snapshot semantics and represents the number of items in the at the moment when Count was accessed.

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false.

Gets a collection containing the keys in the .

An containing the keys in the .

Gets a collection containing the values in the .

An containing the values in the .

Gets a value indicating whether the dictionary is read-only.

true if the is read-only; otherwise, false. For , this property always returns false.

Gets a value indicating whether the has a fixed size.

true if the has a fixed size; otherwise, false. For , this property always returns false.

Gets a value indicating whether the is read-only.

true if the is read-only; otherwise, false. For , this property always returns false.

Gets an containing the keys of the .

An containing the keys of the .

Gets an containing the values in the .

An containing the values in the .

Gets or sets the value associated with the specified key.

The key of the value to get or set. The value associated with the specified key, or a null reference (Nothing in Visual Basic) if is not in the dictionary or is of a type that is not assignable to the key type of the . is a null reference (Nothing in Visual Basic). A value is being assigned, and is of a type that is not assignable to the key type of the . -or- A value is being assigned, and is of a type that is not assignable to the value type of the

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized (thread safe); otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

The number of concurrent writes for which to optimize by default.

A node in a singly-linked list representing a particular hash table bucket.

A private class to represent enumeration over the dictionary that implements the IDictionaryEnumerator interface.

Represents a thread-safe first-in, first-out collection of objects.

Specifies the type of elements in the queue. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Defines methods to manipulate thread-safe collections intended for producer/consumer usage.

Specifies the type of elements in the collection. All implementations of this interface must enable all members of this interface to be used concurrently from multiple threads.

Copies the elements of the to an , starting at a specified index.

The one-dimensional that is the destination of the elements copied from the . The array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Attempts to add an object to the .

The object to add to the . true if the object was added successfully; otherwise, false. The was invalid for this collection.

Attempts to remove and return an object from the .

When this method returns, if the object was removed and returned successfully, contains the removed object. If no object was available to be removed, the value is unspecified. true if an object was removed and returned successfully; otherwise, false.

Copies the elements contained in the to a new array.

A new array containing the elements copied from the .

Initializes a new instance of the class.

Initializes the contents of the queue from an existing collection.

A collection from which to copy elements.

Initializes a new instance of the class that contains elements copied from the specified collection

The collection whose elements are copied to the new . The argument is null.

Get the data array to be serialized

Construct the queue from a previously seiralized one

Copies the elements of the to an , starting at a particular index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is multidimensional. -or- does not have zero-based indexing. -or- is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination . -or- The type of the source cannot be cast automatically to the type of the destination .

Returns an enumerator that iterates through a collection.

An that can be used to iterate through the collection.

Attempts to add an object to the .

The object to add to the . The value can be a null reference (Nothing in Visual Basic) for reference types. true if the object was added successfully; otherwise, false. For , this operation will always add the object to the end of the and return true.

Attempts to remove and return an object from the .

When this method returns, if the operation was successful, contains the object removed. If no object was available to be removed, the value is unspecified. true if an element was removed and returned succesfully; otherwise, false. For , this operation will attempt to remove the object from the beginning of the .

Copies the elements stored in the to a new array.

A new array containing a snapshot of elements copied from the .

Copies the elements to a new .

A new containing a snapshot of elements copied from the .

Store the position of the current head and tail positions.

return the head segment return the tail segment return the head offset return the tail offset

Copies the elements to an existing one-dimensional Array, starting at the specified array index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The enumeration represents a moment-in-time snapshot of the contents of the queue. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the queue.

Adds an object to the end of the .

The object to add to the end of the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Attempts to remove and return the object at the beginning of the .

When this method returns, if the operation was successful, contains the object removed. If no object was available to be removed, the value is unspecified. true if an element was removed and returned from the beggining of the succesfully; otherwise, false.

Attempts to return an object from the beginning of the without removing it.

When this method returns, contains an object from the beginning of the or an unspecified value if the operation failed. true if and object was returned successfully; otherwise, false.

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false. For determining whether the collection contains any items, use of this property is recommended rather than retrieving the number of items from the property and comparing it to 0. However, as this collection is intended to be accessed concurrently, it may be the case that another thread will modify the collection after returns, thus invalidating the result.

Gets the number of elements contained in the .

The number of elements contained in the . For determining whether the collection contains any items, use of the property is recommended rather than retrieving the number of items from the property and comparing it to 0.

private class for ConcurrentQueue. a queue is a linked list of small arrays, each node is called a segment. A segment contains an array, a pointer to the next segment, and m_low, m_high indices recording the first and last valid elements of the array.

Create and initialize a segment with the specified index.

Add an element to the tail of the current segment exclusively called by ConcurrentQueue.InitializedFromCollection InitializeFromCollection is responsible to guaratee that there is no index overflow, and there is no contention

Create a new segment and append to the current one Does not update the m_tail pointer exclusively called by ConcurrentQueue.InitializedFromCollection InitializeFromCollection is responsible to guaratee that there is no index overflow, and there is no contention

the reference to the new Segment

Create a new segment and append to the current one Update the m_tail pointer This method is called when there is no contention

Try to append an element at the end of this segment.

the element to append The tail. true if the element is appended, false if the current segment is full if appending the specified element succeeds, and after which the segment is full, then grow the segment

try to remove an element from the head of current segment

The result. The head. return false only if the current segment is empty

try to peek the current segment

holds the return value of the element at the head position, value set to default(T) if there is no such an element true if there are elements in the current segment, false otherwise

Convert part or all of the current segment into a List

the start position the end position the result list

return the next segment

return true if the current segment is empty (doesn't have any element available to dequeue, false otherwise

return the position of the head of the current segment

return the logical position of the tail of the current segment

Represents a thread-safe last-in, first-out collection of objects.

Specifies the type of elements in the stack. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initializes a new instance of the class.

Initializes a new instance of the class that contains elements copied from the specified collection

The collection whose elements are copied to the new . The argument is null.

Initializes the contents of the stack from an existing collection.

A collection from which to copy elements.

Get the data array to be serialized

Construct the stack from a previously seiralized one

Removes all objects from the .

Copies the elements of the to an , starting at a particular index.

The one-dimensional that is the destination of the elements copied from the . The must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is multidimensional. -or- does not have zero-based indexing. -or- is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination . -or- The type of the source cannot be cast automatically to the type of the destination .

Copies the elements to an existing one-dimensional , starting at the specified array index.

The one-dimensional that is the destination of the elements copied from the . The must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- The number of elements in the source is greater than the available space from to the end of the destination .

Inserts an object at the top of the .

The object to push onto the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Inserts multiple objects at the top of the atomically.

The objects to push onto the . is a null reference (Nothing in Visual Basic). When adding multiple items to the stack, using PushRange is a more efficient mechanism than using one item at a time. Additionally, PushRange guarantees that all of the elements will be added atomically, meaning that no other threads will be able to inject elements between the elements being pushed. Items at lower indices in the array will be pushed before items at higher indices.

Inserts multiple objects at the top of the atomically.

The objects to push onto the . The zero-based offset in at which to begin inserting elements onto the top of the . The number of elements to be inserted onto the top of the . is a null reference (Nothing in Visual Basic). or is negative. Or is greater than or equal to the length of . + is greater than the length of . When adding multiple items to the stack, using PushRange is a more efficient mechanism than using one item at a time. Additionally, PushRange guarantees that all of the elements will be added atomically, meaning that no other threads will be able to inject elements between the elements being pushed. Items at lower indices in the array will be pushed before items at higher indices.

Push one or many nodes into the stack, if head and tails are equal then push one node to the stack other wise push the list between head and tail to the stack

The head pointer to the new list The tail pointer to the new list

Local helper function to validate the Pop Push range methods input

Attempts to add an object to the .

Attempts to return an object from the top of the without removing it.

When this method returns, contains an object from the top of the or an unspecified value if the operation failed. true if and object was returned successfully; otherwise, false.

Attempts to pop and return the object at the top of the .

Attempts to pop and return multiple objects from the top of the atomically.

The to which objects popped from the top of the will be added. The number of objects successfully popped from the top of the and inserted in . is a null argument (Nothing in Visual Basic). When popping multiple items, if there is little contention on the stack, using TryPopRange can be more efficient than using once per item to be removed. Nodes fill the with the first node to be popped at the startIndex, the second node to be popped at startIndex + 1, and so on.

Attempts to pop and return multiple objects from the top of the atomically.

The to which objects popped from the top of the will be added. The zero-based offset in at which to begin inserting elements from the top of the . The number of elements to be popped from top of the and inserted into . is a null reference (Nothing in Visual Basic). or is negative. Or is greater than or equal to the length of . + is greater than the length of . When popping multiple items, if there is little contention on the stack, using TryPopRange can be more efficient than using once per item to be removed. Nodes fill the with the first node to be popped at the startIndex, the second node to be popped at startIndex + 1, and so on.

Local helper function to Pop an item from the stack, slow path

The popped item True if succeeded, false otherwise

Slow path helper for TryPop. This method assumes an initial attempt to pop an element has already occurred and failed, so it begins spinning right away.

The number of items to pop. When this method returns, if the pop succeeded, contains the removed object. If no object was available to be removed, the value is unspecified. This parameter is passed uninitialized. True if an element was removed and returned; otherwise, false.

Local helper function to copy the poped elements into a given collection

The head of the list to be copied The collection to place the popped items in the beginning of index of where to place the popped items The number of nodes.

Attempts to remove and return an object from the .

Copies the items stored in the to a new array.

A new array containing a snapshot of elements copied from the .

Returns an array containing a snapshot of the list's contents, using the target list node as the head of a region in the list.

An array of the list's contents.

Returns an enumerator that iterates through the .

An enumerator for the . The enumeration represents a moment-in-time snapshot of the contents of the stack. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the stack.

Returns an enumerator that iterates through a collection.

An that can be used to iterate through the collection. The enumeration represents a moment-in-time snapshot of the contents of the stack. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the stack.

Gets a value that indicates whether the is empty.

Gets the number of elements contained in the .

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported

A simple (internal) node type used to store elements of concurrent stacks and queues.

Constructs a new node with the specified value and no next node.

The value of the node.

A debugger view of the IProducerConsumerCollection that makes it simple to browse the collection's contents at a point in time.

The type of elements stored within.

Constructs a new debugger view object for the provided collection object.

A collection to browse in the debugger.

Returns a snapshot of the underlying collection's elements.

Represents a particular manner of splitting an orderable data source into multiple partitions.

Type of the elements in the collection. Each element in each partition has an integer index associated with it, which determines the relative order of that element against elements in other partitions. Inheritors of must adhere to the following rules:

All indices must be unique, such that there may not be duplicate indices. If all indices are not unique, the output ordering may be scrambled.
All indices must be non-negative. If any indices are negative, consumers of the implementation may throw exceptions.
and should throw a if the requested partition count is less than or equal to zero.
and should always return a number of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot create as many partitions as requested, an empty enumerator should be returned for each of the remaining partitions. If this rule is not followed, consumers of the implementation may throw a .
, , , and should never return null. If null is returned, a consumer of the implementation may throw a .
, , , and should always return partitions that can fully and uniquely enumerate the input data source. All of the data and only the data contained in the input source should be enumerated, with no duplication that was not already in the input, unless specifically required by the particular partitioner's design. If this is not followed, the output ordering may be scrambled.
If returns true, each partition must return elements with increasing key indices.
If returns true, all the keys in partition numbered N must be larger than all the keys in partition numbered N-1.
If returns true, all indices must be monotonically increasing from 0, though not necessarily within a single partition.

Represents a particular manner of splitting a data source into multiple partitions.

Type of the elements in the collection. Inheritors of must adhere to the following rules:

should throw a if the requested partition count is less than or equal to zero.
should always return a number of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot create as many partitions as requested, an empty enumerator should be returned for each of the remaining partitions. If this rule is not followed, consumers of the implementation may throw a .
and should never return null. If null is returned, a consumer of the implementation may throw a .
and should always return partitions that can fully and uniquely enumerate the input data source. All of the data and only the data contained in the input source should be enumerated, with no duplication that was not already in the input, unless specifically required by the particular partitioner's design. If this is not followed, the output ordering may be scrambled.

Partitions the underlying collection into the given number of partitions.

The number of partitions to create. A list containing enumerators.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. The method is only supported if the property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Gets whether additional partitions can be created dynamically.

true if the can create partitions dynamically as they are requested; false if the can only allocate partitions statically. If a derived class does not override and implement , should return false. The value of should not vary over the lifetime of this instance.

Initializes a new instance of the class with the specified constraints on the index keys.

Indicates whether the elements in each partition are yielded in the order of increasing keys. Indicates whether elements in an earlier partition always come before elements in a later partition. If true, each element in partition 0 has a smaller order key than any element in partition 1, each element in partition 1 has a smaller order key than any element in partition 2, and so on. Indicates whether keys are normalized. If true, all order keys are distinct integers in the range [0 .. numberOfElements-1]. If false, order keys must still be dictinct, but only their relative order is considered, not their absolute values.

Partitions the underlying collection into the specified number of orderable partitions.

Each partition is represented as an enumerator over key-value pairs. The value of the pair is the element itself, and the key is an integer which determines the relative ordering of this element against other elements in the data source. The number of partitions to create. A list containing enumerators.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. Each partition is represented as an enumerator over key-value pairs. The value in the pair is the element itself, and the key is an integer which determines the relative ordering of this element against other elements. The method is only supported if the SupportsDynamicPartitions property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Partitions the underlying collection into the given number of ordered partitions.

The default implementation provides the same behavior as except that the returned set of partitions does not provide the keys for the elements. The number of partitions to create. A list containing enumerators.

Creates an object that can partition the underlying collection into a variable number of partitions.

The returned object implements the interface. Calling GetEnumerator on the object creates another partition over the sequence. The default implementation provides the same behavior as except that the returned set of partitions does not provide the keys for the elements. The method is only supported if the property returns true. An object that can create partitions over the underlying data source. Dynamic partitioning is not supported by this partitioner.

Gets whether elements in each partition are yielded in the order of increasing keys.

Gets whether elements in an earlier partition always come before elements in a later partition.

If returns true, each element in partition 0 has a smaller order key than any element in partition 1, each element in partition 1 has a smaller order key than any element in partition 2, and so on.

Gets whether order keys are normalized.

If returns true, all order keys are distinct integers in the range [0 .. numberOfElements-1]. If the property returns false, order keys must still be dictinct, but only their relative order is considered, not their absolute values.

Converts an enumerable over key-value pairs to an enumerable over values.

Provides common partitioning strategies for arrays, lists, and enumerables.

The static methods on are all thread-safe and may be used concurrently from multiple threads. However, while a created partitioner is in use, the underlying data source should not be modified, whether from the same thread that's using a partitioner or from a separate thread.

Creates an orderable partitioner from an instance.

Type of the elements in source list. The list to be partitioned. A Boolean value that indicates whether the created partitioner should dynamically load balance between partitions rather than statically partition. An orderable partitioner based on the input list.

Creates an orderable partitioner from a instance.

Type of the elements in source array. The array to be partitioned. A Boolean value that indicates whether the created partitioner should dynamically load balance between partitions rather than statically partition. An orderable partitioner based on the input array.

Creates an orderable partitioner from a instance.

Type of the elements in source enumerable. The enumerable to be partitioned. An orderable partitioner based on the input array. The ordering used in the created partitioner is determined by the natural order of the elements as retrieved from the source enumerable.

DynamicPartitionEnumerator_Abstract defines the enumerator for each partition for the dynamic load-balance partitioning algorithm. - Partition is an enumerator of KeyValuePairs, each corresponding to an item in the data source: the key is the index in the source collection; the value is the item itself. - a set of such partitions share a reader over data source. The type of the reader is specified by TSourceReader. - each partition requests a contiguous chunk of elements at a time from the source data. The chunk size is initially 1, and doubles every time until it reaches the maximum chunk size. The implementation for GrabNextChunk() method has two versions: one for data source of IndexRange types (IList and the array), one for data source of IEnumerable. - The method "Reset" is not supported for any partitioning algorithm. - The implementation for MoveNext() method is same for all dynanmic partitioners, so we provide it in this abstract class.

Type of the elements in the data source Type of the reader on the data source

Abstract method to request a contiguous chunk of elements from the source collection

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

Dispose is abstract, and depends on the type of the source data: - For source data type IList and Array, the type of the shared reader is just the dataitself. We don't do anything in Dispose method for IList and Array. - For source data type IEnumerable, the type of the shared reader is an enumerator we created. Thus we need to dispose this shared reader enumerator, when there is no more active partitions left.

Reset on partitions is not supported

Moves to the next element if any. Try current chunk first, if the current chunk do not have any elements left, then we attempt to grab a chunk from the source collection.

true if successfully moving to the next position; false otherwise, if and only if there is no more elements left in the current chunk AND the source collection is exhausted.

Abstract property, returns whether or not the shared reader has already read the last element of the source data

Get the current element in the current partition. Property required by IEnumerator interface This property is abstract because the implementation is different depending on the type of the source data: IList, Array or IEnumerable

Get the current element in the current partition. Property required by IEnumerator interface

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForIEnumerator defined internally

Type of elements in the source data

Overrides OrderablePartitioner.GetOrderablePartitions. Partitions the underlying collection into the given number of orderable partitions.

number of partitions requested A list containing enumerators.

Overrides OrderablePartitioner.GetOrderableDyanmicPartitions

a enumerable collection of orderable partitions

Whether additional partitions can be created dynamically.

Provides customized implementation for source data of IEnumerable Different from the counterpart for IList/Array, this enumerable maintains several additional fields shared by the partitions it owns, including a boolean "m_hasNoElementsLef", a shared lock, and a shared count "m_activePartitionCount"

Inherits from DynamicPartitionEnumerator_Abstract directly Provides customized implementation for: GrabNextChunk, HasNoElementsLeft, Current, Dispose

Reserves a contiguous range of elements from source data

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

If the current partition is to be disposed, we decrement the number of active partitions for the shared reader. If the number of active partitions becomes 0, we need to dispose the shared reader we created

Returns whether or not the shared reader has already read the last element of the source data

We cannot call m_sharedReader.MoveNext(), to see if it hits the last element or not, because we can't undo MoveNext(). Thus we need to maintain a shared boolean value m_hasNoElementsLeft across all partitions

Dynamic load-balance partitioner. This class is abstract and to be derived from by the customized partitioner classes for IList, Array, and IEnumerable

Type of the elements in the source data Type of the source data collection

Constructs a new orderable partitioner

source data collection

Partition the source data and create an enumerable over the resulting partitions.

the source data collection an enumerable of partitions of

Overrides OrderablePartitioner.GetOrderablePartitions. Partitions the underlying collection into the given number of orderable partitions.

number of partitions requested A list containing enumerators.

Overrides OrderablePartitioner.GetOrderableDyanmicPartitions

a enumerable collection of orderable partitions

Whether additional partitions can be created dynamically.

Defines dynamic partition for source data of IList and Array. This class inherits DynamicPartitionEnumerator_Abstract - implements GrabNextChunk, HasNoElementsLeft, and Dispose methods for IList and Array - Current property still remains abstract, implementation is different for IList and Array - introduces another abstract method SourceCount, which returns the number of elements in the source data. Implementation differs for IList and Array

Type of the elements in the data source Type of the reader on the source data

Reserves a contiguous range of elements from source data

specified number of elements requested true if we successfully reserved at least one element (up to #=requestedChunkSize) false if all elements in the source collection have been reserved.

For source data type IList and Array, the type of the shared reader is just the data itself. We don't do anything in Dispose method for IList and Array.

Get the number of elements from the source reader. It calls IList.Count or Array.Length

Returns whether or not the shared reader has already read the last element of the source data

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForIList defined internally

Type of elements in the source data

Inherits from PartitionList_Abstract Provides customized implementation for source data of IList

Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract Provides customized implementation of SourceCount property and Current property for IList

return a KeyValuePair of the current element and its key

Inherits from DynamicPartitioners Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance of EnumerableOfPartitionsForArray defined internally

Type of elements in the source data

Inherits from PartitionList_Abstract Provides customized implementation for source data of Array

Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract Provides customized implementation of SourceCount property and Current property for Array

Static partitioning over IList. - dynamic and load-balance - Keys are ordered within each partition - Keys are ordered across partitions - Keys are normalized - Number of partitions is fixed once specified, and the elements of the source data are distributed to each partition as evenly as possible.

type of the elements Type of the source data collection

Abstract method to create a partition that covers a range over source data, starting from "startIndex", ending at "endIndex"

start index of the current partition on the source data end index of the current partition on the source data a partition enumerator over the specified range

Overrides OrderablePartitioner.GetOrderablePartitions Return a list of partitions, each of which enumerate a fixed part of the source data The elements of the source data are distributed to each partition as evenly as possible. Specifically, if the total number of elements is N, and number of partitions is x, and N = a*x +b, where a is the quotient, and b is the remainder. Then the first b partitions each has a + 1 elements, and the last x-b partitions each has a elements. For example, if N=10, x =3, then partition 0 ranges [0,3], partition 1 ranges [4,6], partition 2 ranges [7,9]. This also takes care of the situation of (x>N), the last x-N partitions are empty enumerators. An empty enumerator is indicated by (m_startIndex == list.Count && m_endIndex == list.Count -1)

specified number of partitions a list of partitions

Abstract method to return the number of elements in the source data

Static Partition for IList/Array. This class implements all methods required by IEnumerator interface, except for the Current property. Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element retrieval.

Constructs an instance of StaticIndexRangePartition

the start index in the source collection for the current partition the end index in the source collection for the current partition

We don't dispose the source for IList and array

Moves to the next item Before the first MoveNext is called: m_offset == m_startIndex-1;

true if successful, false if there is no item left

Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element retrieval.

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition

Inherits from StaticIndexRangePartition Provides customized implementation of Current property

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition for Array

Inherits from StaticIndexRangePartitioner Provides customized implementation of SourceCount and CreatePartition

A very simple primitive that allows us to share a value across multiple threads.

Represents one or more errors that occur during application execution.

is used to consolidate multiple failures into a single, throwable exception object.

Initializes a new instance of the class.

Initializes a new instance of the class with a specified error message.

The error message that explains the reason for the exception.

Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception.

The error message that explains the reason for the exception. The exception that is the cause of the current exception. The argument is null.

Initializes a new instance of the class with references to the inner exceptions that are the cause of this exception.

The exceptions that are the cause of the current exception. The argument is null. An element of is null.

Initializes a new instance of the class with references to the inner exceptions that are the cause of this exception.

The exceptions that are the cause of the current exception. The argument is null. An element of is null.

Initializes a new instance of the class with a specified error message and references to the inner exceptions that are the cause of this exception.

The error message that explains the reason for the exception. The exceptions that are the cause of the current exception. The argument is null. An element of is null.

Initializes a new instance of the class with a specified error message and references to the inner exceptions that are the cause of this exception.

The error message that explains the reason for the exception. The exceptions that are the cause of the current exception. The argument is null. An element of is null.

Allocates a new aggregate exception with the specified message and list of inner exceptions.

The error message that explains the reason for the exception. The exceptions that are the cause of the current exception. The argument is null. An element of is null.

Initializes a new instance of the class with serialized data.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination. The argument is null. The exception could not be deserialized correctly.

Sets the with information about the exception.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination. The argument is null.

Returns the that is the root cause of this exception.

Invokes a handler on each contained by this .

The predicate to execute for each exception. The predicate accepts as an argument the to be processed and returns a Boolean to indicate whether the exception was handled. Each invocation of the returns true or false to indicate whether the was handled. After all invocations, if any exceptions went unhandled, all unhandled exceptions will be put into a new which will be thrown. Otherwise, the method simply returns. If any invocations of the throws an exception, it will halt the processing of any more exceptions and immediately propagate the thrown exception as-is. An exception contained by this was not handled. The argument is null.

Flattens an instances into a single, new instance.

A new, flattened . If any inner exceptions are themselves instances of , this method will recursively flatten all of them. The inner exceptions returned in the new will be the union of all of the the inner exceptions from exception tree rooted at the provided instance.

Creates and returns a string representation of the current .

A string representation of the current exception.

Gets a read-only collection of the instances that caused the current exception.

Encapsulates a method that has five parameters and returns a value of the type specified by the TResult parameter.

Propogates notification that operations should be canceled.

A may be created directly in an unchangeable canceled or non-canceled state using the CancellationToken's constructors. However, to have a CancellationToken that can change from a non-canceled to a canceled state, CancellationTokenSource must be used. CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its Token property. Once canceled, a token may not transition to a non-canceled state, and a token whose is false will never change to one that can be canceled. All members of this struct are thread-safe and may be used concurrently from multiple threads.

Internal constructor only a CancellationTokenSource should create a CancellationToken

Initializes the CancellationToken.

The canceled state for the token. Tokens created with this constructor will remain in the canceled state specified by the parameter. If is false, both and will be false. If is true, both and will be true.

Registers a delegate that will be called when this CancellationToken is canceled.

If this token is already in the canceled state, the delegate will be run immediately and synchronously. Any exception the delegate generates will be propogated out of this method call. The current ExecutionContext, if one exists, will be captured along with the delegate and will be used when executing it. The delegate to be executed when the CancellationToken is canceled. The instance that can be used to deregister the callback. is null. The associated CancellationTokenSource has been disposed.

Registers a delegate that will be called when this CancellationToken is canceled.

If this token is already in the canceled state, the delegate will be run immediately and synchronously. Any exception the delegate generates will be propogated out of this method call. The current ExecutionContext, if one exists, will be captured along with the delegate and will be used when executing it. The delegate to be executed when the CancellationToken is canceled. A Boolean value that indicates whether to capture the current SynchronizationContext and use it when invoking the . The instance that can be used to deregister the callback. is null. The associated CancellationTokenSource has been disposed.

Registers a delegate that will be called when this CancellationToken is canceled.

If this token is already in the canceled state, the delegate will be run immediately and synchronously. Any exception the delegate generates will be propogated out of this method call. The current ExecutionContext, if one exists, will be captured along with the delegate and will be used when executing it. The delegate to be executed when the CancellationToken is canceled. The state to pass to the when the delegate is invoked. This may be null. The instance that can be used to deregister the callback. is null. The associated CancellationTokenSource has been disposed.

Registers a delegate that will be called when this CancellationToken is canceled.

If this token is already in the canceled state, the delegate will be run immediately and synchronously. Any exception the delegate generates will be propogated out of this method call. The current ExecutionContext, if one exists, will be captured along with the delegate and will be used when executing it. The delegate to be executed when the CancellationToken is canceled. The state to pass to the when the delegate is invoked. This may be null. A Boolean value that indicates whether to capture the current SynchronizationContext and use it when invoking the . The instance that can be used to deregister the callback. is null. The associated CancellationTokenSource has been disposed.

Determines whether the current CancellationToken instance is equal to the specified token.

The other CancellationToken to which to compare this instance. True if the instances are equal; otherwise, false. Two tokens are equal if they are associated with the same CancellationTokenSource or if they were both constructed from public CancellationToken constructors and their values are equal.

Determines whether the current CancellationToken instance is equal to the specified .

The other object to which to compare this instance. True if is a CancellationToken and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated with the same CancellationTokenSource or if they were both constructed from public CancellationToken constructors and their values are equal. An associated CancellationTokenSource has been disposed.

Serves as a hash function for a CancellationToken.

A hash code for the current CancellationToken instance.

Determines whether two CancellationToken instances are equal.

The first instance. The second instance. True if the instances are equal; otherwise, false. An associated CancellationTokenSource has been disposed.

Determines whether two CancellationToken instances are not equal.

The first instance. The second instance. True if the instances are not equal; otherwise, false. An associated CancellationTokenSource has been disposed.

Throws a OperationCanceledException if this token has had cancellation requested.

This method provides functionality equivalent to:


            if (token.IsCancellationRequested) 
               throw new OperationCanceledException(token);

The token has had cancellation requested. The associated CancellationTokenSource has been disposed.

Returns an empty CancellationToken value.

The value returned by this property will be non-cancelable by default.

Gets whether cancellation has been requested for this token.

Whether cancellation has been requested for this token. This property indicates whether cancellation has been requested for this token, either through the token initially being construted in a canceled state, or through calling Cancel on the token's associated . If this property is true, it only guarantees that cancellation has been requested. It does not guarantee that every registered handler has finished executing, nor that cancellation requests have finished propagating to all registered handlers. Additional synchronization may be required, particularly in situations where related objects are being canceled concurrently.

Gets whether this token is capable of being in the canceled state.

If CanBeCanceled returns false, it is guaranteed that the token will never transition into a canceled state, meaning that will never return true.

Gets a that is signaled when the token is canceled.

Accessing this property causes a WaitHandle to be instantiated. It is preferable to only use this property when necessary, and to then dispose the associated instance at the earliest opportunity (disposing the source will dispose of this allocated handle). The handle should not be closed or disposed directly. The associated CancellationTokenSource has been disposed.

Represents a callback delegate that has been registered with a CancellationToken.

To unregister a callback, dispose the corresponding Registration instance.

Attempts to deregister the item. If it's already being run, this may fail. Entails a full memory fence.

True if the callback was found and deregistered, false otherwise.

Disposes of the registration and unregisters the target callback from the associated CancellationToken. If the target callback is currently executing this method will wait until it completes, except in the degenerate cases where a callback method deregisters itself.

Determines whether two CancellationTokenRegistration instances are equal.

The first instance. The second instance. True if the instances are equal; otherwise, false.

Determines whether two CancellationTokenRegistration instances are not equal.

The first instance. The second instance. True if the instances are not equal; otherwise, false.

Determines whether the current CancellationTokenRegistration instance is equal to the specified .

The other object to which to compare this instance. True, if both this and are equal. False, otherwise. Two CancellationTokenRegistration instances are equal if they both refer to the output of a single call to the same Register method of a CancellationToken.

Determines whether the current CancellationToken instance is equal to the specified .

The other CancellationTokenRegistration to which to compare this instance. True, if both this and are equal. False, otherwise. Two CancellationTokenRegistration instances are equal if they both refer to the output of a single call to the same Register method of a CancellationToken.

Serves as a hash function for a CancellationTokenRegistration..

A hash code for the current CancellationTokenRegistration instance.

Signals to a that it should be canceled.

is used to instantiate a (via the source's Token property) that can be handed to operations that wish to be notified of cancellation or that can be used to register asynchronous operations for cancellation. That token may have cancellation requested by calling to the source's Cancel method. All members of this class, except Dispose, are thread-safe and may be used concurrently from multiple threads. The ID of the thread currently executing the main body of CTS.Cancel() this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to actually run the callbacks.

Initializes the .

Communicates a request for cancellation.

The associated will be notified of the cancellation and will transition to a state where IsCancellationRequested returns true. Any callbacks or cancelable operations registered with the will be executed. Cancelable operations and callbacks registered with the token should not throw exceptions. However, this overload of Cancel will aggregate any exceptions thrown into a , such that one callback throwing an exception will not prevent other registered callbacks from being executed. The that was captured when each callback was registered will be reestablished when the callback is invoked. An aggregate exception containing all the exceptions thrown by the registered callbacks on the associated . This has been disposed.

Communicates a request for cancellation.

The associated will be notified of the cancellation and will transition to a state where IsCancellationRequested returns true. Any callbacks or cancelable operations registered with the will be executed. Cancelable operations and callbacks registered with the token should not throw exceptions. If is true, an exception will immediately propagate out of the call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. If is false, this overload will aggregate any exceptions thrown into a , such that one callback throwing an exception will not prevent other registered callbacks from being executed. The that was captured when each callback was registered will be reestablished when the callback is invoked. Specifies whether exceptions should immediately propagate. An aggregate exception containing all the exceptions thrown by the registered callbacks on the associated . This has been disposed.

Releases the resources used by this .

This method is not thread-safe for any other concurrent calls.

Throws an exception if the source has been disposed.

InternalGetStaticSource()

Whether the source should be set. A static source to be shared among multiple tokens.

Registers a callback object. If cancellation has already occurred, the callback will have been run by the time this method returns.

Invoke the Canceled event.

The handlers are invoked synchronously in LIFO order.

Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens are in the canceled state.

The first CancellationToken to observe. The second CancellationToken to observe. A CancellationTokenSource that is linked to the source tokens. A CancellationTokenSource associated with one of the source tokens has been disposed.

Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens are in the canceled state.

The CancellationToken instances to observe. A CancellationTokenSource that is linked to the source tokens. is null. A CancellationTokenSource associated with one of the source tokens has been disposed.

Gets whether cancellation has been requested for this CancellationTokenSource.

Whether cancellation has been requested for this CancellationTokenSource. This property indicates whether cancellation has been requested for this token source, such as due to a call to its Cancel method. If this property returns true, it only guarantees that cancellation has been requested. It does not guarantee that every handler registered with the corresponding token has finished executing, nor that cancellation requests have finished propagating to all registered handlers. Additional synchronization may be required, particularly in situations where related objects are being canceled concurrently.

A simple helper to determine whether cancellation has finished.

A simple helper to determine whether disposal has occured.

The ID of the thread that is running callbacks.

Gets the CancellationToken associated with this .

The CancellationToken associated with this . The token source has been disposed.

The currently executing callback

A helper class for collating the various bits of information required to execute cancellation callbacks.

InternalExecuteCallbackSynchronously_GeneralPath This will be called on the target synchronization context, however, we still need to restore the required execution context

A sparsely populated array. Elements can be sparse and some null, but this allows for lock-free additions and growth, and also for constant time removal (by nulling out).

The kind of elements contained within.

Allocates a new array with the given initial size.

How many array slots to pre-allocate.

Adds an element in the first available slot, beginning the search from the tail-to-head. If no slots are available, the array is grown. The method doesn't return until successful.

The element to add. Information about where the add happened, to enable O(1) deregistration.

The head of the doubly linked list.

The tail of the doubly linked list.

A struct to hold a link to the exact spot in an array an element was inserted, enabling constant time removal later on.

A fragment of a sparsely populated array, doubly linked.

The kind of elements contained within.

Represents a synchronization primitive that is signaled when its count reaches zero.

All public and protected members of are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the have completed, and Reset, which should only be used when no other threads are accessing the event.

Initializes a new instance of class with the specified count.

The number of signals required to set the . is less than 0.

Releases all resources used by the current instance of .

Unlike most of the members of , is not thread-safe and may not be used concurrently with other members of this instance.

When overridden in a derived class, releases the unmanaged resources used by the , and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources. Unlike most of the members of , is not thread-safe and may not be used concurrently with other members of this instance.

Registers a signal with the , decrementing its count.

true if the signal caused the count to reach zero and the event was set; otherwise, false. The current instance is already set. The current instance has already been disposed.

Registers multiple signals with the , decrementing its count by the specified amount.

The number of signals to register. true if the signals caused the count to reach zero and the event was set; otherwise, false. The current instance is already set. -or- Or is greater than . is less than 1. The current instance has already been disposed.

Increments the 's current count by one.

The current instance is already set. is equal to . The current instance has already been disposed.

Attempts to increment the 's current count by one.

true if the increment succeeded; otherwise, false. If is already at zero. this will return false. is equal to . The current instance has already been disposed.

Increments the 's current count by a specified value.

The value by which to increase . is less than 0. The current instance is already set. is equal to . The current instance has already been disposed.

Attempts to increment the 's current count by a specified value.

The value by which to increase . true if the increment succeeded; otherwise, false. If is already at zero this will return false. is less than 0. The current instance is already set. is equal to . The current instance has already been disposed.

Resets the to the value of .

Unlike most of the members of , Reset is not thread-safe and may not be used concurrently with other members of this instance. The current instance has already been disposed..

Resets the to a specified value.

The number of signals required to set the . Unlike most of the members of , Reset is not thread-safe and may not be used concurrently with other members of this instance. is less than 0. The current instance has alread been disposed.

Blocks the current thread until the is set.

The caller of this method blocks indefinitely until the current instance is set. The caller will return immediately if the event is currently in a set state. The current instance has already been disposed.

Blocks the current thread until the is set, while observing a .

The to observe. The caller of this method blocks indefinitely until the current instance is set. The caller will return immediately if the event is currently in a set state. If the CancellationToken being observed is canceled during the wait operation, an will be thrown. has been canceled. The current instance has already been disposed.

Blocks the current thread until the is set, using a to measure the time interval.

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if the was set; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The current instance has already been disposed.

Blocks the current thread until the is set, using a to measure the time interval, while observing a .

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The to observe. true if the was set; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The current instance has already been disposed. has been canceled.

Blocks the current thread until the is set, using a 32-bit signed integer to measure the time interval.

The number of milliseconds to wait, or (-1) to wait indefinitely. true if the was set; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The current instance has already been disposed.

Blocks the current thread until the is set, using a 32-bit signed integer to measure the time interval, while observing a .

The number of milliseconds to wait, or (-1) to wait indefinitely. The to observe. true if the was set; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The current instance has already been disposed. has been canceled.

Throws an exception if the latch has been disposed.

Gets the number of remaining signals required to set the event.

The number of remaining signals required to set the event.

Gets the numbers of signals initially required to set the event.

The number of signals initially required to set the event.

Determines whether the event is set.

true if the event is set; otherwise, false.

Gets a that is used to wait for the event to be set.

A that is used to wait for the event to be set. The current instance has already been disposed. should only be used if it's needed for integration with code bases that rely on having a WaitHandle. If all that's needed is to wait for the to be set, the method should be preferred.

Provides a slimmed down version of .

Initializes a new instance of the class with an initial state of nonsignaled.

Initializes a new instance of the class with a Boolen value indicating whether to set the intial state to signaled.

true to set the initial state signaled; false to set the initial state to nonsignaled.

Initializes a new instance of the class with a Boolen value indicating whether to set the intial state to signaled and a specified spin count.

true to set the initial state to signaled; false to set the initial state to nonsignaled. The number of spin waits that will occur before falling back to a true wait. is less than 0 or greater than the maximum allowed value.

Initializes the internal state of the event.

Whether the event is set initially or not. The spin count that decides when the event will block.

Helper to ensure the lock object is created before first use.

This method lazily initializes the event object. It uses CAS to guarantee that many threads racing to call this at once don't result in more than one event being stored and used. The event will be signaled or unsignaled depending on the state of the thin-event itself, with synchronization taken into account.

True if a new event was created and stored, false otherwise.

Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

Private helper to actually perform the Set.

Indicates whether we are calling Set() during cancellation. The object has been canceled.

Sets the state of the event to nonsignaled, which causes threads to block.

Unlike most of the members of , is not thread-safe and may not be used concurrently with other members of this instance.

Blocks the current thread until the current is set.

The maximum number of waiters has been exceeded. The caller of this method blocks indefinitely until the current instance is set. The caller will return immediately if the event is currently in a set state.

Blocks the current thread until the current receives a signal, while observing a .

The to observe. The maximum number of waiters has been exceeded. was canceled. The caller of this method blocks indefinitely until the current instance is set. The caller will return immediately if the event is currently in a set state.

Blocks the current thread until the current is set, using a to measure the time interval.

Blocks the current thread until the current is set, using a to measure the time interval, while observing a .

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The to observe. true if the was set; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . was canceled. The maximum number of waiters has been exceeded.

Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval.

Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval, while observing a .

The number of milliseconds to wait, or (-1) to wait indefinitely. The to observe. true if the was set; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The maximum number of waiters has been exceeded. was canceled.

Releases all resources used by the current instance of .

Unlike most of the members of , is not thread-safe and may not be used concurrently with other members of this instance.

When overridden in a derived class, releases the unmanaged resources used by the , and optionally releases the managed resources.

Throw ObjectDisposedException if the MRES is disposed

Private helper method to wake up waiters when a cancellationToken gets canceled.

Private helper method for updating parts of a bit-string state value. Mainly called from the IsSet and Waiters properties setters

Note: the parameter types must be int as CompareExchange cannot take a Uint The new value The mask used to set the bits

Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer ?? is there a common place to put this rather than being private to MRES?

Performs a Mask operation, but does not perform the shift. This is acceptable for boolean values for which the shift is unnecessary eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using ((val & Mask) >> shiftAmount) == 1 ?? is there a common place to put this rather than being private to MRES?

Helper function to measure and update the wait time

The first time (in Ticks) observed when the wait started. The orginal wait timeoutout in milliseconds. The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters has occurred.

Gets the underlying object for this .

The underlying event object fore this . Accessing this property forces initialization of an underlying event object if one hasn't already been created. To simply wait on this , the public Wait methods should be preferred.

Gets whether the event is set.

true if the event has is set; otherwise, false.

Gets the number of spin waits that will be occur before falling back to a true wait.

How many threads are waiting.

Provides support for lazy initialization.

Specifies the type of element being laziliy initialized. By default, all public and protected members of are thread-safe and may be used concurrently from multiple threads. These thread-safety guarantees may be removed optionally and per instance using parameters to the type's constructors.

Initializes a new instance of the class that uses 's default constructor for lazy initialization.

An instance created with this constructor may be used concurrently from multiple threads.

Initializes a new instance of the class that uses a specified initialization function.

The invoked to produce the lazily-initialized value when it is needed. is a null reference (Nothing in Visual Basic). An instance created with this constructor may be used concurrently from multiple threads.

Initializes a new instance of the class that uses 's default constructor and a specified thread-safety mode.

true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time.

Initializes a new instance of the class that uses 's default constructor and a specified thread-safety mode.

The lazy thread-safety mode mode mode contains an invalid valuee

Initializes a new instance of the class that uses a specified initialization function and a specified thread-safety mode.

The invoked to produce the lazily-initialized value when it is needed. true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time. is a null reference (Nothing in Visual Basic).

Initializes a new instance of the class that uses a specified initialization function and a specified thread-safety mode.

The invoked to produce the lazily-initialized value when it is needed. The lazy thread-safety mode. is a null reference (Nothing in Visual Basic). mode contains an invalid value.

Static helper function that returns an object based on the given mode. it also throws an exception if the mode is invalid

Forces initialization during serialization.

The StreamingContext for the serialization operation.

Creates and returns a string representation of this instance.

The result of calling on the . The is null.

local helper method to initialize the value

The inititialized T value

Creates an instance of T using m_valueFactory in case its not null or use reflection to create a new T()

An instance of Boxed.

Gets the value of the Lazy<T> for debugging display purposes.

Gets a value indicating whether this instance may be used concurrently from multiple threads.

Gets whether the value creation is faulted or not

Gets a value indicating whether the has been initialized.

true if the instance has been initialized; otherwise, false. The initialization of a instance may result in either a value being produced or an exception being thrown. If an exception goes unhandled during initialization, will return false.

wrapper class to box the initialized value, this is mainly created to avoid boxing/unboxing the value each time the value is called in case T is a value type

Wrapper class to wrap the excpetion thrown by the value factory

A debugger view of the Lazy<T> to surface additional debugging properties and to ensure that the Lazy<T> does not become initialized if it was not already.

Constructs a new debugger view object for the provided Lazy object.

A Lazy object to browse in the debugger.

Returns whether the Lazy object is initialized or not.

Returns the value of the Lazy object.

Returns the execution mode of the Lazy object

Specifies how a instance should synchronize access among multiple threads.

This mode makes no guarantees around the thread-safety of the instance. If used from multiple threads, the behavior of the is undefined. This mode should be used when a is guaranteed to never be initialized from more than one thread simultaneously and high performance is crucial. If valueFactory throws an exception when the is initialized, the exception will be cached and returned on subsequent accesses to Value. Also, if valueFactory recursively accesses Value on this instance, a will be thrown.

When multiple threads attempt to simultaneously initialize a instance, this mode allows each thread to execute the valueFactory but only the first thread to complete initialization will be allowed to set the final value of the . Once initialized successfully, any future calls to Value will return the cached result. If valueFactory throws an exception on any thread, that exception will be propagated out of Value. If any thread executes valueFactory without throwing an exception and, therefore, successfully sets the value, that value will be returned on subsequent accesses to Value from any thread. If no thread succeeds in setting the value, IsValueCreated will remain false and subsequent accesses to Value will result in the valueFactory delegate re-executing. Also, if valueFactory recursively accesses Value on this instance, an exception will NOT be thrown.

This mode uses locks to ensure that only a single thread can initialize a instance in a thread-safe manner. In general, taken if this mode is used in conjunction with a valueFactory delegate that uses locks internally, a deadlock can occur if not handled carefully. If valueFactory throws an exception when the is initialized, the exception will be cached and returned on subsequent accesses to Value. Also, if valueFactory recursively accesses Value on this instance, a will be thrown.

Provides lazy initialization routines.

These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using references to ensure targets have been initialized as they are accessed.

Initializes a target reference type with the type's default constructor if the target has not already been initialized.

The refence type of the reference to be initialized. A reference of type to initialize if it has not already been initialized. The initialized reference of type . Type does not have a default constructor. Permissions to access the constructor of type were missing. This method may only be used on reference types. To ensure initialization of value types, see other overloads of EnsureInitialized. This method may be used concurrently by multiple threads to initialize . In the event that multiple threads access this method concurrently, multiple instances of may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the objects that were not stored. If such objects must be disposed, it is up to the caller to determine if an object was not used and to then dispose of the object appropriately.

Initializes a target reference type using the specified function if it has not already been initialized.

The reference type of the reference to be initialized. The reference of type to initialize if it has not already been initialized. The invoked to initialize the reference. The initialized reference of type . Type does not have a default constructor. returned null. This method may only be used on reference types, and may not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or to allow null reference types, see other overloads of EnsureInitialized. This method may be used concurrently by multiple threads to initialize . In the event that multiple threads access this method concurrently, multiple instances of may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the objects that were not stored. If such objects must be disposed, it is up to the caller to determine if an object was not used and to then dispose of the object appropriately.

Initialize the target using the given delegate (slow path).

The reference type of the reference to be initialized. The variable that need to be initialized The delegate that will be executed to initialize the target The initialized variable

Initializes a target reference or value type with its default constructor if it has not already been initialized.

The type of the reference to be initialized. A reference or value of type to initialize if it has not already been initialized. A reference to a boolean that determines whether the target has already been initialized. A reference to an object used as the mutually exclusive lock for initializing . The initialized value of type .

Initializes a target reference or value type with a specified function if it has not already been initialized.

Ensure the target is initialized and return the value (slow path). This overload permits nulls and also works for value type targets. Uses the supplied function to create the value.

The type of target. A reference to the target to be initialized. A reference to a location tracking whether the target has been initialized. A reference to a location containing a mutual exclusive lock. The to invoke in order to produce the lazily-initialized value. The initialized object.

A seprate non generic class that contains a global counter for fast path instances for all Ts that has been created, and adds an upper limit for all instances that uses the fast path, if this limit has been reached, all new instances will use the slow path

Provides thread-local storage of data.

Specifies the type of data stored per-thread. With the exception of , all public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initializes the instance.

Initializes the instance with the specified function.

The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. is a null reference (Nothing in Visual Basic).

Releases the resources used by this instance.

Unlike most of the members of , this method is not thread-safe.

Releases the resources used by this instance.

A Boolean value that indicates whether this method is being called due to a call to . Unlike most of the members of , this method is not thread-safe.

Tries to get a unique index for the current instance of type T, it first tries to get it from the pool if it is not empty, otherwise it increments the global counter if it is still below the maximum, otherwise it fails and returns -1

True if there is an index available, false otherwise

Gets an array of types that will be used as generic parameters for the GenericHolder class

The types array

Creates and returns a string representation of this instance for the current thread.

The result of calling on the . The for the current thread is a null reference (Nothing in Visual Basic). The initialization function referenced in an improper manner. The instance has been disposed. Calling this method forces initialization for the current thread, as is the case with accessing directly.

Private helper function to lazily create the value using the calueSelector if specified in the constructor or the default parameterless constructor

Returns the boxed object

Gets or sets the value of this instance for the current thread.

The initialization function referenced in an improper manner. The instance has been disposed. If this instance was not previously initialized for the current thread, accessing will attempt to initialize it. If an initialization function was supplied during the construction, that initialization will happen by invoking the function to retrieve the initial value for . Otherwise, the default value of will be used.

Gets whether is initialized on the current thread.

The instance has been disposed.

Gets the value of the ThreadLocal<T> for debugging display purposes. It takes care of getting the value for the current thread in the ThreadLocal mode.

The base abstract class for the holder

The TLS holder representation

The generic holder representation

Dummy param Dummy param Dummy param

wrapper to the actual value

A debugger view of the ThreadLocal<T> to surface additional debugging properties and to ensure that the ThreadLocal<T> does not become initialized if it was not already.

Constructs a new debugger view object for the provided ThreadLocal object.

A ThreadLocal object to browse in the debugger.

Returns whether the ThreadLocal object is initialized or not.

Returns the value of the ThreadLocal object.

Limits the number of threads that can access a resource or pool of resources concurrently.

The provides a lightweight semaphore class that doesn't use Windows kernel semaphores. All public and protected members of are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the have completed.

Initializes a new instance of the class, specifying the initial number of requests that can be granted concurrently.

The initial number of requests for the semaphore that can be granted concurrently. is less than 0.

Initializes a new instance of the class, specifying the initial and maximum number of requests that can be granted concurrently.

The initial number of requests for the semaphore that can be granted concurrently. The maximum number of requests for the semaphore that can be granted concurrently. is less than 0. -or- is greater than . -or- is less than 0.

Blocks the current thread until it can enter the .

The current instance has already been disposed.

Blocks the current thread until it can enter the , while observing a .

The token to observe. was canceled. The current instance has already been disposed.

Blocks the current thread until it can enter the , using a to measure the time interval.

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if the current thread successfully entered the ; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Blocks the current thread until it can enter the , using a to measure the time interval, while observing a .

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The to observe. true if the current thread successfully entered the ; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . was canceled.

Blocks the current thread until it can enter the , using a 32-bit signed integer to measure the time interval.

The number of milliseconds to wait, or (-1) to wait indefinitely. true if the current thread successfully entered the ; otherwise, false. is a negative number other than -1, which represents an infinite time-out.

Blocks the current thread until it can enter the , using a 32-bit signed integer to measure the time interval, while observing a .

The number of milliseconds to wait, or (-1) to wait indefinitely. The to observe. true if the current thread successfully entered the ; otherwise, false. is a negative number other than -1, which represents an infinite time-out. was canceled.

Local helper function, waits on the monitor until the monitor recieves signal or the timeout is expired

The maximum timeout The start ticks to calculate the elapsed time The CancellationToken to observe. true if the monitor recieved a signal, false if the timeout expired

Exits the once.

The previous count of the . The current instance has already been disposed.

Exits the a specified number of times.

The number of times to exit the semaphore. The previous count of the . is less than 1. The has already reached its maximum size. The current instance has already been disposed.

Releases all resources used by the current instance of .

Unlike most of the members of , is not thread-safe and may not be used concurrently with other members of this instance.

When overridden in a derived class, releases the unmanaged resources used by the , and optionally releases the managed resources.

Helper function to measure and update the wait time

The first time (in Ticks) observed when the wait started The orginal wait timeoutout in milliseconds The new wait time in milliseconds, -1 if the time expired

Private helper method to wake up waiters when a cancellationToken gets canceled.

Checks the dispose status by checking the lock object, if it is null means that object has been disposed and throw ObjectDisposedException

local helper function to retrieve the exception string message from the resource file

The key string

Gets the current count of the .

The current count of the .

Returns a that can be used to wait on the semaphore.

A that can be used to wait on the semaphore. A successful wait on the does not imply a successful wait on the itself, nor does it decrement the semaphore's count. exists to allow a thread to block waiting on multiple semaphores, but such a wait should be followed by a true wait on the target semaphore. The has been disposed.

Provides support for spin-based waiting.

encapsulates common spinning logic. On single-processor machines, yields are always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of spinning and true yielding. is a value type, which means that low-level code can utilize SpinWait without fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. In most cases, you should use the synchronization classes provided by the .NET Framework, such as . For most purposes where spin waiting is required, however, the type should be preferred over the method. While SpinWait is designed to be used in concurrent applications, it is not designed to be used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple threads must spin, each should use its own instance of SpinWait.

Performs a single spin.

This is typically called in a loop, and may change in behavior based on the number of times a has been called thus far on this instance.

Resets the spin counter.

This makes and behave as though no calls to had been issued on this instance. If a instance is reused many times, it may be useful to reset it to avoid yielding too soon.

Spins until the specified condition is satisfied.

A delegate to be executed over and over until it returns true. The argument is null.

Spins until the specified condition is satisfied or until the specified timeout is expired.

A delegate to be executed over and over until it returns true. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. True if the condition is satisfied within the timeout; otherwise, false The argument is null. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Spins until the specified condition is satisfied or until the specified timeout is expired.

A delegate to be executed over and over until it returns true. The number of milliseconds to wait, or (-1) to wait indefinitely. True if the condition is satisfied within the timeout; otherwise, false The argument is null. is a negative number other than -1, which represents an infinite time-out.

Gets the number of times has been called on this instance.

Gets whether the next call to will yield the processor, triggering a forced context switch.

Whether the next call to will yield the processor, triggering a forced context switch. On a single-CPU machine, always yields the processor. On machines with multiple CPUs, may yield after an unspecified number of calls.

A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval

Gets the number of available processors

Gets whether the current machine has only a single processor.

Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available.

Spin locks can be used for leaf-level locks where the object allocation implied by using a , in size or due to garbage collection pressure, is overly expensive. Avoiding blocking is another reason that a spin lock can be useful, however if you expect any significant amount of blocking, you are probably best not using spin locks due to excessive spinning. Spinning can be beneficial when locks are fine grained and large in number (for example, a lock per node in a linked list) as well as when lock hold times are always extremely short. In general, while holding a spin lock, one should avoid blocking, calling anything that itself may block, holding more than one spin lock at once, making dynamically dispatched calls (interface and virtuals), making statically dispatched calls into any code one doesn't own, or allocating memory. should only be used when it's been determined that doing so will improve an application's performance. It's also important to note that is a value type, for performance reasons. As such, one must be very careful not to accidentally copy a SpinLock instance, as the two instances (the original and the copy) would then be completely independent of one another, which would likely lead to erroneous behavior of the application. If a SpinLock instance must be passed around, it should be passed by reference rather than by value. Do not store instances in readonly fields. All members of are thread-safe and may be used from multiple threads concurrently.

Initializes a new instance of the structure with the option to track thread IDs to improve debugging.

The default constructor for tracks thread ownership. Whether to capture and use thread IDs for debugging purposes.

Initializes a new instance of the structure with the option to track thread IDs to improve debugging.

The default constructor for tracks thread ownership.

Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

is a non-reentrant lock, meaning that if a thread holds the lock, it is not allowed to enter the lock again. If thread ownership tracking is enabled (whether it's enabled is available through ), an exception will be thrown when a thread tries to re-enter a lock it already holds. However, if thread ownership tracking is disabled, attempting to enter a lock already held will result in deadlock. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling Enter.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block waiting for the lock to be available. If the lock is not available when TryEnter is called, it will return immediately without any further spinning. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block indefinitely waiting for the lock to be available. It will block until either the lock is available or until the has expired. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than milliseconds.

Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired.

Unlike , TryEnter will not block indefinitely waiting for the lock to be available. It will block until either the lock is available or until the has expired. The number of milliseconds to wait, or (-1) to wait indefinitely. True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. Thread ownership tracking is enabled, and the current thread has already acquired this lock. The argument must be initialized to false prior to calling TryEnter. is a negative number other than -1, which represents an infinite time-out.

Try acquire the lock with long path, this is usually called after the first path in Enter and TryEnter failed The reason for short path is to make it inline in the run time which improves the performance. This method assumed that the parameter are validated in Enter ir TryENter method

The timeout milliseconds The lockTaken param

decrements the waiters, in case of the timeout is expired

ContinueTryEnter for the thread tracking mode enabled

Helper function to validate the timeout

The start time in ticks The orginal wait time True if expired, false otherwise

Releases the lock.

The default overload of provides the same behavior as if calling using true as the argument. Thread ownership tracking is enabled, and the current thread is not the owner of this lock.

Releases the lock.

A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads. Calling with the argument set to true will improve the fairness of the lock at the expense of some performance. The default overload behaves as if specifying true for . Thread ownership tracking is enabled, and the current thread is not the owner of this lock.

Gets whether the lock is currently held by any thread.

Gets whether the lock is held by the current thread.

If the lock was initialized to track owner threads, this will return whether the lock is acquired by the current thread. It is invalid to use this property when the lock was initialized to not track thread ownership. Thread ownership tracking is disabled.

Gets whether thread ownership tracking is enabled for this instance.

Internal class used by debug type proxy attribute to display the owner thread ID

SystemThreading_SpinLockDebugView constructor

The SpinLock to be proxied.

Checks if the lock is held by the current thread or not

Gets the current owner thread, zero if it is released

Gets whether the lock is currently held by any thread or not.

Stores options that configure the operation of methods on the Parallel class.

By default, methods on the Parallel class attempt to utilize all available processors, are non-cancelable, and target the default TaskScheduler (TaskScheduler.Default). enables overriding these defaults.

Initializes a new instance of the class.

This constructor initializes the instance with default values. is initialized to -1, signifying that there is no upper bound set on how much parallelism should be employed. is initialized to a non-cancelable token, and is initialized to the default scheduler (TaskScheduler.Default). All of these defaults may be overwritten using the property set accessors on the instance.

Gets or sets the TaskScheduler associated with this instance. Setting this property to null indicates that the current scheduler should be used.

Gets or sets the maximum degree of parallelism enabled by this ParallelOptions instance.

The limits the number of concurrent operations run by Parallel method calls that are passed this ParallelOptions instance to the set value, if it is positive. If is -1, then there is no limit placed on the number of concurrently running operations. The exception that is thrown when this is set to 0 or some value less than -1.

Gets or sets the CancellationToken associated with this instance.

Providing a CancellationToken to a Parallel method enables the operation to be exited early. Code external to the operation may cancel the token, and if the operation observes the token being set, it may exit early by throwing an .

Provides support for parallel loops and regions.

The class provides library-based data parallel replacements for common operations such as for loops, for each loops, and execution of a set of statements.

Executes each of the provided actions, possibly in parallel.

An array of Actions to execute. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null element. The exception that is thrown when any action in the array throws an exception. This method can be used to execute a set of operations, potentially in parallel. No guarantees are made about the order in which the operations execute or whether they execute in parallel. This method does not return until each of the provided operations has completed, regardless of whether completion occurs due to normal or exceptional termination.

Executes each of the provided actions, possibly in parallel.

A ParallelOptions instance that configures the behavior of this operation. An array of Actions to execute. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null element. The exception that is thrown when the CancellationToken in the is set. The exception that is thrown when any action in the array throws an exception. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. This method can be used to execute a set of operations, potentially in parallel. No guarantees are made about the order in which the operations execute or whether the they execute in parallel. This method does not return until each of the provided operations has completed, regardless of whether completion occurs due to normal or exceptional termination.

Executes a for loop in which iterations may run in parallel.

The start index, inclusive. The end index, exclusive. A ParallelOptions instance that configures the behavior of this operation. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the iteration count (an Int32) as a parameter.

Executes a for loop in which iterations may run in parallel.

The start index, inclusive. The end index, exclusive. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), and a ParallelLoopState instance that may be used to break out of the loop prematurely. Calling ParallelLoopState.Break() informs the For operation that iterations after the current one need not execute. However, all iterations before the current one will still need to be executed if they have not already. Therefore, calling Break is similar to using a break operation within a conventional for loop in a language like C#, but it is not a perfect substitute: for example, there is no guarantee that iterations after the current one will definitely not execute. If executing all iterations before the current one is not necessary, ParallelLoopState.Stop() should be preferred to using Break. Calling Stop informs the For loop that it may abandon all remaining iterations, regardless of whether they're for interations above or below the current, since all required work has already been completed. As with Break, however, there are no guarantees regarding which other iterations will not execute. When a loop is ended prematurely, the that's returned will contain relevant information about the loop's completion.

Executes a for loop in which iterations may run in parallel.

The type of the thread-local data. The start index, inclusive. The end index, exclusive. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for loop in which iterations may run in parallel. Supports 64-bit indices.

The type of the thread-local data. The start index, inclusive. The end index, exclusive. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for loop in which iterations may run in parallel.

The type of the thread-local data. The start index, inclusive. The end index, exclusive. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for loop in which iterations may run in parallel.

The type of the thread-local data. The start index, inclusive. The end index, exclusive. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each value in the iteration range: [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Performs the major work of the parallel for loop. It assumes that argument validation has already been performed by the caller. This function's whole purpose in life is to enable as much reuse of common implementation details for the various For overloads we offer. Without it, we'd end up with lots of duplicate code. It handles: (1) simple for loops, (2) for loops that depend on ParallelState, and (3) for loops with thread local data. @TODO: at some point in the future, we may want to manually inline the interesting bits into the specific overloads above. There is some overhead associated with the extra arguments passed to the function, and various if-checks in the code. It is also more difficult to follow what the code does as-is because it has to handle the three flavors.

The type of the local data. The loop's start index, inclusive. The loop's end index, exclusive. A ParallelOptions instance. The simple loop body. The loop body for ParallelState overloads. The loop body for thread local state overloads. A selector function that returns new thread local state. A cleanup function to destroy thread local state. Only one of the body arguments may be supplied (i.e. they are exclusive). A structure.

Performs the major work of the 64-bit parallel for loop. It assumes that argument validation has already been performed by the caller. This function's whole purpose in life is to enable as much reuse of common implementation details for the various For overloads we offer. Without it, we'd end up with lots of duplicate code. It handles: (1) simple for loops, (2) for loops that depend on ParallelState, and (3) for loops with thread local data. @TODO: at some point in the future, we may want to manually inline the interesting bits into the specific overloads above. There is some overhead associated with the extra arguments passed to the function, and various if-checks in the code. It is also more difficult to follow what the code does as-is because it has to handle the three flavors.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. An enumerable data source. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the current element as a parameter.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. An enumerable data source. A ParallelOptions instance that configures the behavior of this operation. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the current element as a parameter.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. The type of the thread-local data. An enumerable data source. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. The type of the thread-local data. An enumerable data source. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. The type of the thread-local data. An enumerable data source. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (an Int64), and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on an in which iterations may run in parallel.

The type of the data in the source. The type of the thread-local data. An enumerable data source. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (an Int64), and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Performs the major work of the parallel foreach loop. It assumes that argument validation has already been performed by the caller. This function's whole purpose in life is to enable as much reuse of common implementation details for the various For overloads we offer. Without it, we'd end up with lots of duplicate code. It handles: (1) simple foreach loops, (2) foreach loops that depend on ParallelState, and (3) foreach loops that access indices, (4) foreach loops with thread local data, and any necessary permutations thereof. @TODO: at some point in the future, we may want to manually inline the interesting bits into the specific overloads above. There is some overhead associated with the extra arguments passed to the function, and various if-checks in the code. It is also more difficult to follow what the code does as-is because it has to handle the all flavors.

The type of the source data. The type of the local data. An enumerable data source. ParallelOptions instance to use with this ForEach-loop The simple loop body. The loop body for ParallelState overloads. The loop body for ParallelState/indexed overloads. The loop body for ParallelState/thread local state overloads. The loop body for ParallelState/indexed/thread local state overloads. A selector function that returns new thread local state. A cleanup function to destroy thread local state. Only one of the bodyXX arguments may be supplied (i.e. they are exclusive). A structure.

A fast path for the more general ForEachWorker method above. This uses ldelem instructions to access the individual elements of the array, which will be faster.

The type of the source data. The type of the local data. An array data source. The options to use for execution. The simple loop body. The loop body for ParallelState overloads. The loop body for indexed/ParallelLoopState overloads. The loop body for local/ParallelLoopState overloads. The loop body for the most generic overload. A selector function that returns new thread local state. A cleanup function to destroy thread local state. A structure.

A fast path for the more general ForEachWorker method above. This uses IList<T>'s indexer capabilities to access the individual elements of the list rather than an enumerator.

The type of the source data. The type of the local data. A list data source. The options to use for execution. The simple loop body. The loop body for ParallelState overloads. The loop body for indexed/ParallelLoopState overloads. The loop body for local/ParallelLoopState overloads. The loop body for the most generic overload. A selector function that returns new thread local state. A cleanup function to destroy thread local state. A structure.

Executes a for each operation on a Partitioner in which iterations may run in parallel.

The type of the elements in . The Partitioner that contains the original data source. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the SupportsDynamicPartitions property in the Partitioner returns false. The exception that is thrown when any methods in the Partitioner return null. The exception that is thrown when the GetPartitions() method in the Partitioner does not return the correct number of partitions. The exception that is thrown when the GetPartitions() method in the Partitioner returns an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() method in the Partitioner returns an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the current element as a parameter.

Executes a for each operation on a Partitioner in which iterations may run in parallel.

Executes a for each operation on a OrderablePartitioner in which iterations may run in parallel.

The type of the elements in . The OrderablePartitioner that contains the original data source. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the SupportsDynamicPartitions property in the OrderablePartitioner returns false. The exception that is thrown when the KeysNormalized property in the OrderablePartitioner returns false. The exception that is thrown when any methods in the OrderablePartitioner return null. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner do not return the correct number of partitions. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner return an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and the current element's index (an Int64).

Executes a for each operation on a Partitioner in which iterations may run in parallel.

The type of the elements in . The type of the thread-local data. The Partitioner that contains the original data source. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the SupportsDynamicPartitions property in the Partitioner returns false. The exception that is thrown when any methods in the Partitioner return null. The exception that is thrown when the GetPartitions() method in the Partitioner does not return the correct number of partitions. The exception that is thrown when the GetPartitions() method in the Partitioner returns an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() method in the Partitioner returns an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on a OrderablePartitioner in which iterations may run in parallel.

The type of the elements in . The type of the thread-local data. The OrderablePartitioner that contains the original data source. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the SupportsDynamicPartitions property in the OrderablePartitioner returns false. The exception that is thrown when the KeysNormalized property in the OrderablePartitioner returns false. The exception that is thrown when any methods in the OrderablePartitioner return null. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner do not return the correct number of partitions. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner return an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (an Int64), and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on a Partitioner in which iterations may run in parallel.

The type of the elements in . The Partitioner that contains the original data source. A ParallelOptions instance that configures the behavior of this operation. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown when the SupportsDynamicPartitions property in the Partitioner returns false. The exception that is thrown when any methods in the Partitioner return null. The exception that is thrown when the GetPartitions() method in the Partitioner does not return the correct number of partitions. The exception that is thrown when the GetPartitions() method in the Partitioner returns an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() method in the Partitioner returns an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the current element as a parameter.

Executes a for each operation on a Partitioner in which iterations may run in parallel.

Executes a for each operation on a OrderablePartitioner in which iterations may run in parallel.

The type of the elements in . The OrderablePartitioner that contains the original data source. A ParallelOptions instance that configures the behavior of this operation. The delegate that is invoked once per iteration. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown when the SupportsDynamicPartitions property in the OrderablePartitioner returns false. The exception that is thrown when the KeysNormalized property in the OrderablePartitioner returns false. The exception that is thrown when any methods in the OrderablePartitioner return null. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner do not return the correct number of partitions. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner return an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and the current element's index (an Int64).

Executes a for each operation on a Partitioner in which iterations may run in parallel.

The type of the elements in . The type of the thread-local data. The Partitioner that contains the original data source. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown when the SupportsDynamicPartitions property in the Partitioner returns false. The exception that is thrown when any methods in the Partitioner return null. The exception that is thrown when the GetPartitions() method in the Partitioner does not return the correct number of partitions. The exception that is thrown when the GetPartitions() method in the Partitioner returns an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() method in the Partitioner returns an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Executes a for each operation on a OrderablePartitioner in which iterations may run in parallel.

The type of the elements in . The type of the thread-local data. The OrderablePartitioner that contains the original data source. A ParallelOptions instance that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the CancellationToken in the argument is set The exception that is thrown when the SupportsDynamicPartitions property in the OrderablePartitioner returns false. The exception that is thrown when the KeysNormalized property in the OrderablePartitioner returns false. The exception that is thrown when any methods in the OrderablePartitioner return null. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner do not return the correct number of partitions. The exception that is thrown when the GetPartitions() or GetOrderablePartitions() methods in the OrderablePartitioner return an IList with at least one null value. The exception that is thrown when the GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. The exception that is thrown to contain an exception thrown from one of the specified delegates. The exception that is thrown when the the CancellationTokenSource associated with the the CancellationToken in the has been disposed. A ParallelLoopResult structure that contains information on what portion of the loop completed. The Partitioner is used to retrieve the elements to be processed, in place of the original data source. If the current element's index is desired, the source must be an OrderablePartitioner. The delegate is invoked once for each element in the Partitioner. It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (an Int64), and some local state that may be shared amongst iterations that execute on the same thread. The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final action on each thread's local state.

Internal utility function that implements the OCE filtering behavior for all Parallel.* APIs. Throws a single OperationCancelledException object with the token if the Exception collection only contains OperationCancelledExceptions with the given CancellationToken.

The exception collection to filter The CancellationToken expected on all inner exceptions

Enables iterations of loops to interact with other iterations.

Communicates that the loop should cease execution at the system's earliest convenience.

The method was previously called. and may not be used in combination by iterations of the same loop. may be used to communicate to the loop that no other iterations need be run. For long-running iterations that may already be executing, causes to return true for all other iterations of the loop, such that another iteration may check and exit early if it's observed to be true. is typically employed in search-based algorithms, where once a result is found, no other iterations need be executed.

Communicates that the loop should cease execution at the system's earliest convenience of iterations beyond the current iteration.

The method was previously called. and may not be used in combination by iterations of the same loop. may be used to communicate to the loop that no other iterations after the current iteration need be run. For example, if is called from the 100th iteration of a for loop iterating in parallel from 0 to 1000, all iterations less than 100 should still be run, but the iterations from 101 through to 1000 are not necessary. For long-running iterations that may already be executing, causes to be set to the current iteration's index if the current index is less than the current value of . is typically employed in search-based algorithms where an ordering is present in the data source.

Internal/virtual support for ShouldExitCurrentIteration.

Gets whether the current iteration of the loop should exit based on requests made by this or other iterations.

When an iteration of a loop calls or , or when one throws an exception, or when the loop is canceled, the class will proactively attempt to prohibit additional iterations of the loop from starting execution. However, there may be cases where it is unable to prevent additional iterations from starting. It may also be the case that a long-running iteration has already begun execution. In such cases, iterations may explicitly check the property and cease execution if the property returns true.

Gets whether any iteration of the loop has called .

Gets whether any iteration of the loop has thrown an exception that went unhandled by that iteration.

Internal/virtual support for LowestBreakIteration.

Gets the lowest iteration of the loop from which was called.

If no iteration of the loop called , this property will return null.

Internal constructor to ensure an instance isn't created by users.

A flag shared among all threads participating in the execution of a certain loop.

Communicates that parallel tasks should stop when they reach a specified iteration element. (which is CurrentIteration of the caller).

Break() called after Stop(). This is shared with all other concurrent threads in the system which are participating in the loop's execution. After calling Break(), no additional iterations will be executed on the current thread, and other worker threads will execute once they get beyond the calling iteration.

Tracks the current loop iteration for the owning task. This is used to compute whether or not the task should terminate early due to a Break() call.

Returns true if we should be exiting from the current iteration due to Stop(), Break() or exception.

Returns the lowest iteration at which Break() has been called, or null if Break() has not yet been called.

Allows independent iterations of a parallel loop to interact with other iterations.

Internal constructor to ensure an instance isn't created by users.

A flag shared among all threads participating in the execution of a certain loop.

Communicates that parallel tasks should stop when they reach a specified iteration element. (which is CurrentIteration of the caller).

Break() called after Stop(). Atomically sets shared StoppedBroken flag to BROKEN, then atomically sets shared LowestBreakIteration to CurrentIteration, but only if CurrentIteration is less than LowestBreakIteration.

Tracks the current loop iteration for the owning task. This is used to compute whether or not the task should terminate early due to a Break() call.

Returns true if we should be exiting from the current iteration due to Stop(), Break() or exception.

Returns the lowest iteration at which Break() has been called, or null if Break() has not yet been called.

State information that is common between ParallelStateFlags class and ParallelStateFlags64 class.

An internal class used to share accounting information in 32-bit versions of For()/ForEach() loops.

Lets the caller know whether or not to prematurely exit the For/ForEach loop. If this returns true, then exit the loop. Otherwise, keep going.

The caller's current iteration point in the loop. The loop should exit on any one of the following conditions: (1) Stop() has been called by one or more tasks. (2) An exception has been raised by one or more tasks. (3) Break() has been called by one or more tasks, and CallerIteration exceeds the (lowest) iteration at which Break() was called. (4) The loop was canceled.

An internal class used to share accounting information in 64-bit versions of For()/ForEach() loops.

Lets the caller know whether or not to prematurely exit the For/ForEach loop. If this returns true, then exit the loop. Otherwise, keep going.

Provides completion status on the execution of a loop.

If returns true, then the loop ran to completion, such that all iterations of the loop were executed. If returns false and returns null, a call to was used to end the loop prematurely. If returns false and returns a non-null integral value, was used to end the loop prematurely.

Gets whether the loop ran to completion, such that all iterations of the loop were executed and the loop didn't receive a request to end prematurely.

Gets the index of the lowest iteration from which was called.

If was not employed, this property will return null.

Utility class for allocating structs as heap variables

Represents an index range

The RangeWorker struct wraps the state needed by a task that services the parallel loop

Initializes a RangeWorker struct

Implements the core work search algorithm that will be used for this range worker.

Usage pattern is: 1) the thread associated with this rangeworker calls FindNewWork 2) if we return true, the worker uses the nFromInclusiveLocal and nToExclusiveLocal values to execute the sequential loop 3) if we return false it means there is no more work left. It's time to quit.

32 bit integer version of FindNewWork. Assumes the ranges were initialized with 32 bit values.

Represents the entire loop operation, keeping track of workers and ranges.

The usage pattern is: 1) The Parallel loop entry function (ForWorker) creates an instance of this class 2) Every thread joining to service the parallel loop calls RegisterWorker to grab a RangeWorker struct to wrap the state it will need to find and execute work, and they keep interacting with that struct until the end of the loop

Initializes a RangeManager with the given loop parameters, and the desired number of outer ranges

The function that needs to be called by each new worker thread servicing the parallel loop in order to get a RangeWorker struct that wraps the state for finding and executing indices

Represents an asynchronous operation that produces a result at some time in the future.

The type of the result produced by this . instances may be created in a variety of ways. The most common approach is by using the task's property to retrieve a instance that can be used to create tasks for several purposes. For example, to create a that runs a function, the factory's StartNew method may be used:


            // C# 
            var t = Task<int>.Factory.StartNew(() => GenerateResult());
            - or -
            var t = Task.Factory.StartNew(() => GenerateResult());
            
            ' Visual Basic 
            Dim t = Task<int>.Factory.StartNew(Function() GenerateResult())
            - or -
            Dim t = Task.Factory.StartNew(Function() GenerateResult())

The class also provides constructors that initialize the task but that do not schedule it for execution. For performance reasons, the StartNew method should be the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, the constructors may be used, and the task's Start method may then be used to schedule the task for execution at a later time. All members of , except for Dispose, are thread-safe and may be used from multiple threads concurrently.

Represents an asynchronous operation.

instances may be created in a variety of ways. The most common approach is by using the Task type's property to retrieve a instance that can be used to create tasks for several purposes. For example, to create a that runs an action, the factory's StartNew method may be used:


            // C# 
            var t = Task.Factory.StartNew(() => DoAction());
            
            ' Visual Basic 
            Dim t = Task.Factory.StartNew(Function() DoAction())

The class also provides constructors that initialize the Task but that do not schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, the constructors may be used, and the task's method may then be used to schedule the task for execution at a later time. All members of , except for , are thread-safe and may be used from multiple threads concurrently. For operations that return values, the class should be used. For developers implementing custom debuggers, several internal and private members of Task may be useful (these may change from release to release). The Int32 m_taskId field serves as the backing store for the property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, information also accessible through the property. The m_action System.Object field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a Task is entering a wait operation.

A type initializer that runs with the appropriate permissions.

Initializes a new with the specified action.

The delegate that represents the code to execute in the Task. The argument is null.

Initializes a new with the specified action and CancellationToken.

The delegate that represents the code to execute in the Task. The CancellationToken that will be assigned to the new Task. The argument is null. The provided CancellationToken has already been disposed.

Initializes a new with the specified action and creation options.

The delegate that represents the code to execute in the task. The TaskCreationOptions used to customize the Task's behavior. The argument is null. The argument specifies an invalid value for .

Initializes a new with the specified action and creation options.

The delegate that represents the code to execute in the task. The that will be assigned to the new task. The TaskCreationOptions used to customize the Task's behavior. The argument is null. The argument specifies an invalid value for . The provided CancellationToken has already been disposed.

Initializes a new with the specified action and state.

The delegate that represents the code to execute in the task. An object representing data to be used by the action. The argument is null.

Initializes a new with the specified action, state, snd options.

The delegate that represents the code to execute in the task. An object representing data to be used by the action. The that will be assigned to the new task. The argument is null. The provided CancellationToken has already been disposed.

Initializes a new with the specified action, state, snd options.

The delegate that represents the code to execute in the task. An object representing data to be used by the action. The TaskCreationOptions used to customize the Task's behavior. The argument is null. The argument specifies an invalid value for .

Initializes a new with the specified action, state, snd options.

The delegate that represents the code to execute in the task. An object representing data to be used by the action. The that will be assigned to the new task. The TaskCreationOptions used to customize the Task's behavior. The argument is null. The argument specifies an invalid value for . The provided CancellationToken has already been disposed.

An internal constructor used by the factory methods on task and its descendent(s). This variant does not capture the ExecutionContext; it is up to the caller to do that.

An action to execute. Optional state to pass to the action. Parent of Task. A CancellationToken for the task. A task scheduler under which the task will run. Options to control its execution. Internal options to control its execution

Common logic used by the following internal ctors: Task() Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) ASSUMES THAT m_creatingTask IS ALREADY SET.

Action for task to execute. Object to which to pass to action (may be null) Task scheduler on which to run thread (only used by continuation tasks). A CancellationToken for the Task. Options to customize behavior of Task. Internal options to customize behavior of Task.

Checks if we registered a CT callback during construction, and deregisters it. This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed successfully or with an exception.

Captures the ExecutionContext so long as flow isn't suppressed.

A stack crawl mark pointing to the frame of the caller.

Internal function that will be called by a new child task to add itself to the children list of the parent (this). Since a child task can only be created from the thread executing the action delegate of this task, reentrancy is neither required nor supported. This should not be called from anywhere other than the task construction/initialization codepaths.

Starts the , scheduling it for execution to the current TaskScheduler.

A task may only be started and run only once. Any attempts to schedule a task a second time will result in an exception. The is not in a valid state to be started. It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling. The instance has been disposed.

Starts the , scheduling it for execution to the specified TaskScheduler.

A task may only be started and run only once. Any attempts to schedule a task a second time will result in an exception. The TaskScheduler with which to associate and execute this task. The argument is null. The is not in a valid state to be started. It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling. The instance has been disposed.

Runs the synchronously on the current TaskScheduler.

A task may only be started and run only once. Any attempts to schedule a task a second time will result in an exception. Tasks executed with will be associated with the current TaskScheduler. If the target scheduler does not support running this Task on the current thread, the Task will be scheduled for execution on the scheduler, and the current thread will block until the Task has completed execution. The is not in a valid state to be started. It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling. The instance has been disposed.

Runs the synchronously on the scheduler provided.

A task may only be started and run only once. Any attempts to schedule a task a second time will result in an exception. If the target scheduler does not support running this Task on the current thread, the Task will be scheduled for execution on the scheduler, and the current thread will block until the Task has completed execution. The is not in a valid state to be started. It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling. The instance has been disposed. The parameter is null. The scheduler on which to attempt to run this task inline.

Throws an exception if the task has been disposed, and hence can no longer be accessed.

The task has been disposed.

Sets the internal completion event.

Disposes the , releasing all of its unmanaged resources.

Unlike most of the members of , this method is not thread-safe. Also, may only be called on a that is in one of the final states: RanToCompletion, Faulted, or Canceled. The exception that is thrown if the is not in one of the final states: RanToCompletion, Faulted, or Canceled.

Disposes the , releasing all of its unmanaged resources.

A Boolean value that indicates whether this method is being called due to a call to . Unlike most of the members of , this method is not thread-safe.

Schedules the task for execution.

If true, TASK_STATE_STARTED bit is turned on in an atomic fashion, making sure that TASK_STATE_CANCELED does not get set underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This allows us to streamline things a bit for StartNew(), where competing cancellations are not a problem.

Adds an exception to the list of exceptions this task has thrown.

An object representing either an Exception or a collection of Exceptions.

Returns a list of exceptions by aggregating the holder's contents. Or null if no exceptions have been thrown.

Whether to include a TCE if cancelled. An aggregate exception, or null if no exceptions have been caught.

Throws an aggregate exception if the task contains exceptions.

Checks whether this is an attached task, and whether we are being called by the parent task. And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. This is meant to be used internally when throwing an exception, and when WaitAll is gathering exceptions for tasks it waited on. If this flag gets set, the implicit wait on children will skip exceptions to prevent duplication. This should only be called when this task has completed with an exception

Signals completion of this particular task. The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the full execution of the user delegate. If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to a cancellation request, or because this task is a promise style Task). In this case, the steps involving child tasks (i.e. WaitForChildren) will be skipped.

FinishStageTwo is to be executed as soon as we known there are no more children to complete. It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) ii) or on the thread that executed the last child.

Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic()

This is called by children of this task when they are completed.

This is to be called just before the task does its final state transition. It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list

Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath such as inlined continuations

Indicates whether the ThreadAbortException was added to this task's exception holder. This should always be true except for the case of non-root self replicating task copies. Whether the delegate was executed.

Executes the task. This method will only be called once, and handles bookeeping associated with self-replicating tasks, in addition to performing necessary exception marshaling.

The task has already been disposed.

IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it.

The ThreadPool calls this if a ThreadAbortException is thrown while trying to execute this workitem. This may occur before Task would otherwise be able to observe it.

Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline.

Performs atomic updates to prevent double execution. Should only be set to true in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this.

The actual code which invokes the body of the task. This can be overriden in derived types.

Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that the Parallel Debugger can discover the actual task being invoked. Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this function appears on the callstack.

Performs whatever handling is necessary for an unhandled exception. Normally this just entails adding the exception to the holder object.

The exception that went unhandled.

Waits for the to complete execution.

The was canceled -or- an exception was thrown during the execution of the . The has been disposed.

Waits for the to complete execution.

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if the completed execution within the allotted time; otherwise, false. The was canceled -or- an exception was thrown during the execution of the . is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The has been disposed.

Waits for the to complete execution.

A to observe while waiting for the task to complete. The was canceled. The was canceled -or- an exception was thrown during the execution of the . The has been disposed.

Waits for the to complete execution.

The number of milliseconds to wait, or (-1) to wait indefinitely. true if the completed execution within the allotted time; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The was canceled -or- an exception was thrown during the execution of the . The has been disposed.

Waits for the to complete execution.

The number of milliseconds to wait, or (-1) to wait indefinitely. A to observe while waiting for the task to complete. true if the completed execution within the allotted time; otherwise, false. The was canceled -or- an exception was thrown during the execution of the . The has been disposed. is a negative number other than -1, which represents an infinite time-out. The was canceled.

The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where the current context is known or cached.

Cancels the .

Indiactes whether we should only cancel non-invoked tasks. For the default scheduler this option will only be serviced through TryDequeue. For custom schedulers we also attempt an atomic state transition. true if the task was successfully canceled; otherwise, false. The has been disposed.

Sets the task's cancellation acknowledged flag.

Runs all of the continuations, as appropriate.

Helper function to determine whether the current task is in the state desired by the continuation kind under evaluation. Three possibilities exist: the task failed with an unhandled exception (OnFailed), the task was canceled before running (OnAborted), or the task completed successfully (OnCompletedSuccessfully). Note that the last one includes completing due to cancellation.

The continuation options under evaluation. True if the continuation should be run given the task's current state.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The has been disposed.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. The that will be assigned to the new continuation task. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The argument is null. The has been disposed.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. A new continuation . The returned will not be scheduled for execution until the current task has completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled instead of scheduled. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The has been disposed.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. The that will be assigned to the new continuation task. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed. If the criteria specified through the parameter are not met, the continuation task will be canceled instead of scheduled. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The has been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. The that will be assigned to the new continuation task. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The argument is null. The has been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. A new continuation . The returned will not be scheduled for execution until the current task has completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled instead of scheduled. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The has been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. The that will be assigned to the new continuation task. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed. If the criteria specified through the parameter are not met, the continuation task will be canceled instead of scheduled. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Converts TaskContinuationOptions to TaskCreationOptions, and also does some validity checking along the way.

Incoming TaskContinuationOptions Outgoing TaskCreationOptions Outgoing InternalTaskOptions

Registers the continuation and possibly runs it (if the task is already finished).

The continuation task itself. TaskScheduler with which to associate continuation task. Restrictions on when the continuation becomes active.

Waits for all of the provided objects to complete execution.

An array of instances on which to wait. The argument is null. The argument contains a null element. At least one of the instances was canceled -or- an exception was thrown during the execution of at least one of the instances. The has been disposed.

Waits for all of the provided objects to complete execution.

true if all of the instances completed execution within the allotted time; otherwise, false. An array of instances on which to wait. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The argument is null. The argument contains a null element. At least one of the instances was canceled -or- an exception was thrown during the execution of at least one of the instances. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The has been disposed.

Waits for all of the provided objects to complete execution.

true if all of the instances completed execution within the allotted time; otherwise, false. The number of milliseconds to wait, or (-1) to wait indefinitely. An array of instances on which to wait. The argument is null. The argument contains a null element. At least one of the instances was canceled -or- an exception was thrown during the execution of at least one of the instances. The has been disposed. is a negative number other than -1, which represents an infinite time-out.

Waits for all of the provided objects to complete execution.

true if all of the instances completed execution within the allotted time; otherwise, false. An array of instances on which to wait. A to observe while waiting for the tasks to complete. The argument is null. The argument contains a null element. At least one of the instances was canceled -or- an exception was thrown during the execution of at least one of the instances. The was canceled. The has been disposed.

Waits for all of the provided objects to complete execution.

true if all of the instances completed execution within the allotted time; otherwise, false. An array of instances on which to wait. The number of milliseconds to wait, or (-1) to wait indefinitely. A to observe while waiting for the tasks to complete. The argument is null. The argument contains a null element. At least one of the instances was canceled -or- an exception was thrown during the execution of at least one of the instances. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The was canceled.

Waits for a set of handles in a STA-aware way. In other words, it will wait for each of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx can't do a true wait-all due to its hidden message queue event. This is not atomic, of course, but we only wait on one-way (MRE) events anyway so this is OK.

An array of wait handles to wait on. The timeout to use during waits. The cancellationToken that enables a wait to be canceled. True if all waits succeeded, false if a timeout occurred.

Internal WaitAll implementation which is meant to be used with small number of tasks, optimized for Parallel.Invoke and other structured primitives.

This internal function is only meant to be called by WaitAll() If the completed task is canceled or it has other exceptions, here we will add those into the passed in exception list (which will be lazily initialized here).

Waits for any of the provided objects to complete execution.

An array of instances on which to wait. The index of the completed task in the array argument. The argument is null. The argument contains a null element. The has been disposed.

Waits for any of the provided objects to complete execution.

An array of instances on which to wait. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The index of the completed task in the array argument, or -1 if the timeout occurred. The argument is null. The argument contains a null element. The has been disposed. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Waits for any of the provided objects to complete execution.

An array of instances on which to wait. A to observe while waiting for a task to complete. The index of the completed task in the array argument. The argument is null. The argument contains a null element. The has been disposed. The was canceled.

Waits for any of the provided objects to complete execution.

An array of instances on which to wait. The number of milliseconds to wait, or (-1) to wait indefinitely. The index of the completed task in the array argument, or -1 if the timeout occurred. The argument is null. The argument contains a null element. The has been disposed. is a negative number other than -1, which represents an infinite time-out.

Waits for any of the provided objects to complete execution.

An array of instances on which to wait. The number of milliseconds to wait, or (-1) to wait indefinitely. A to observe while waiting for a task to complete. The index of the completed task in the array argument, or -1 if the timeout occurred. The argument is null. The argument contains a null element. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The was canceled.

Gets a unique ID for this Task instance.

Task IDs are assigned on-demand and do not necessarily represent the order in the which Task instances were created.

Returns the unique ID of the currently executing Task.

Gets the Task instance currently executing, or null if none exists.

Gets the StackGuard object assigned to the current thread.

Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a in calls to Wait or in accesses to the property. Any exceptions not observed by the time the Task instance is garbage collected will be propagated on the finalizer thread. The Task has been disposed.

Gets the TaskStatus of this Task.

Gets whether this Task instance has completed execution due to being canceled.

A Task will complete in Canceled state either if its CancellationToken was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on its already signaled CancellationToken by throwing an OperationCanceledException that bears the same CancellationToken.

Returns true if this task has a cancellation token and it was signaled. To be used internally in execute entry codepaths.

This internal property provides access to the CancellationToken that was set on the task when it was constructed.

Gets whether this threw an OperationCanceledException while its CancellationToken was signaled.

Gets whether this Task has completed.

will return true when the Task is in one of the three final states: RanToCompletion, Faulted, or Canceled.

Checks whether this task has been disposed.

Gets the TaskCreationOptions used to create this task.

Gets a that can be used to wait for the task to complete.

Using the wait functionality provided by should be preferred over using for similar functionality. The has been disposed.

Gets the state object supplied when the Task was created, or null if none was supplied.

Gets an indication of whether the asynchronous operation completed synchronously.

true if the asynchronous operation completed synchronously; otherwise, false.

Provides access to the TaskScheduler responsible for executing this Task.

Provides access to factory methods for creating and instances.

The factory returned from is a default instance of , as would result from using the default constructor on TaskFactory.

Provides an event that can be used to wait for completion. Only called by Wait*(), which means that we really do need to instantiate a completion event.

Determines whether this is the root task of a self replicating group.

Determines whether the task is a replica itself.

The property formerly known as IsFaulted.

Gets whether the completed due to an unhandled exception.

If is true, the Task's will be equal to TaskStatus.Faulted, and its property will be non-null.

Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, This will only be used by the implicit wait to prevent double throws

Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task.

A structure to hold continuation information.

Constructs a new continuation structure.

The task to be activated. The continuation options. The scheduler to use for the continuation.

Invokes the continuation for the target completion task.

The completed task. Whether the continuation can be inlined.

Initializes a new with the specified function.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. The argument is null.

Initializes a new with the specified function.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. The to be assigned to this task. The argument is null. The provided CancellationToken has already been disposed.

Initializes a new with the specified function and creation options.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. The TaskCreationOptions used to customize the task's behavior. The argument is null. The argument specifies an invalid value for .

Initializes a new with the specified function and creation options.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. The that will be assigned to the new task. The TaskCreationOptions used to customize the task's behavior. The argument is null. The argument specifies an invalid value for . The provided CancellationToken has already been disposed.

Initializes a new with the specified function and state.

Initializes a new with the specified action, state, and options.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. An object representing data to be used by the function. The to be assigned to the new task. The argument is null. The provided CancellationToken has already been disposed.

Initializes a new with the specified action, state, and options.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. An object representing data to be used by the function. The TaskCreationOptions used to customize the task's behavior. The argument is null. The argument specifies an invalid value for .

Initializes a new with the specified action, state, and options.

The delegate that represents the code to execute in the task. When the function has completed, the task's property will be set to return the result value of the function. An object representing data to be used by the function. The to be assigned to the new task. The TaskCreationOptions used to customize the task's behavior. The argument is null. The argument specifies an invalid value for . The provided CancellationToken has already been disposed.

Creates a new future object.

The parent task for this future. A function that yields the future value. The task scheduler which will be used to execute the future. The CancellationToken for the task. Options to control the future's behavior. Internal options to control the future's behavior. The argument specifies a SelfReplicating , which is illegal."/>.

Creates a new future object.

The parent task for this future. An object containing data to be used by the action; may be null. A function that yields the future value. The CancellationToken for the task. The task scheduler which will be used to execute the future. Options to control the future's behavior. Internal options to control the future's behavior. The argument specifies a SelfReplicating , which is illegal."/>.

Evaluates the value selector of the Task which is passed in as an object and stores the result.

Creates a continuation that executes when the target completes.

An action to run when the completes. When run, the delegate will be passed the completed task as an argument. The that will be assigned to the new continuation task. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed. If the criteria specified through the parameter are not met, the continuation task will be canceled instead of scheduled. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. The that will be assigned to the new task. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed the completed task as an argument. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The , when executed, should return a . This task's completion state will be transferred to the task returned from the ContinueWith call. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The has been disposed.

Creates a continuation that executes when the target completes.

The type of the result produced by the continuation. A function to run when the completes. When run, the delegate will be passed as an argument this completed task. The that will be assigned to the new task. Options for when the continuation is scheduled and how it behaves. This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously. The to associate with the continuation task and to use for its execution. A new continuation . The returned will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled. The , when executed, should return a . This task's completion state will be transferred to the task returned from the ContinueWith call. The argument is null. The argument specifies an invalid value for TaskContinuationOptions. The argument is null. The has been disposed. The provided CancellationToken has already been disposed.

Gets the result value of this .

The get accessor for this property ensures that the asynchronous operation is complete before returning. Once the result of the computation is available, it is stored and will be returned immediately on later calls to .

Provides access to factory methods for creating instances.

The factory returned from is a default instance of , as would result from using the default constructor on the factory type.

Provides support for creating and scheduling Task{TResult} objects.

The type of the results that are available though the Task{TResult} objects that are associated with the methods in this class. There are many common patterns for which tasks are relevant. The class encodes some of these patterns into methods that pick up default settings, which are configurable through its constructors. A default instance of is available through the Task{TResult}.Factory property.

Initializes a instance with the default configuration.

This constructor creates a instance with a default configuration. The property is initialized to TaskCreationOptions.None, the property is initialized to TaskContinuationOptions.None, and the TaskScheduler property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the default configuration.

The default that will be assigned to tasks created by this unless another CancellationToken is explicitly specified while calling the factory methods. This constructor creates a instance with a default configuration. The property is initialized to TaskCreationOptions.None, the property is initialized to TaskContinuationOptions.None, and the TaskScheduler property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the specified configuration.

The TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value indicates that the current TaskScheduler should be used. With this constructor, the property is initialized to TaskCreationOptions.None, the property is initialized to TaskContinuationOptions.None, and the TaskScheduler property is initialized to , unless it's null, in which case the property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the specified configuration.

The default TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. The default TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. The exception that is thrown when the argument or the argument specifies an invalid value. With this constructor, the property is initialized to , the property is initialized to , and the TaskScheduler property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the specified configuration.

The default that will be assigned to tasks created by this unless another CancellationToken is explicitly specified while calling the factory methods. The default TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. The default TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. The default TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value indicates that TaskScheduler.Current should be used. The exception that is thrown when the argument or the argumentspecifies an invalid value. With this constructor, the property is initialized to , the property is initialized to , and the TaskScheduler property is initialized to , unless it's null, in which case the property is initialized to the current scheduler (see TaskScheduler.Current).

Creates and starts a .

A function delegate that returns the future result to be available through the . The started . The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . The that will be assigned to the new task. The started . The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . A TaskCreationOptions value that controls the behavior of the created . The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . A TaskCreationOptions value that controls the behavior of the created . The that will be assigned to the new task. The TaskScheduler that is used to schedule the created Task{TResult}. The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The started . The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The that will be assigned to the new task. The started . The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. A TaskCreationOptions value that controls the behavior of the created . The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The that will be assigned to the new task. A TaskCreationOptions value that controls the behavior of the created . The TaskScheduler that is used to schedule the created Task{TResult}. The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. A Task that represents the asynchronous operation.

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The TaskScheduler that is used to schedule the task that executes the end method. The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the third argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The third argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the third argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The third argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Gets the default CancellationToken of this TaskFactory.

This property returns the default that will be assigned to all tasks created by this factory unless another CancellationToken value is explicitly specified during the call to the factory methods.

Gets the TaskScheduler of this TaskFactory{TResult}.

This property returns the default scheduler for this factory. It will be used to schedule all tasks unless another scheduler is explicitly specified during calls to this factory's methods. If null, TaskScheduler.Current will be used.

Gets the TaskCreationOptions value of this TaskFactory{TResult}.

This property returns the default creation options for this factory. They will be used to create all tasks unless other options are explicitly specified during calls to this factory's methods.

Gets the TaskContinuationOptions value of this TaskFactory{TResult}.

This property returns the default continuation options for this factory. They will be used to create all continuation tasks unless other options are explicitly specified during calls to this factory's methods.

Represents the current stage in the lifecycle of a .

The task has been initialized but has not yet been scheduled.

The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure.

The task has been scheduled for execution but has not yet begun executing.

The task is running but has not yet completed.

The task has finished executing and is implicitly waiting for attached child tasks to complete.

The task completed execution successfully.

The task acknowledged cancellation by throwing an OperationCanceledException with its own CancellationToken while the token was in signaled state, or the task's CancellationToken was already signaled before the task started executing.

The task completed due to an unhandled exception.

In some cases a replica will want to quit prematurely (ie. before finishing a chunk of work it may have grabbed) yet they will need the next replica to pick things up from where they left. This API is used to save such state. Calling it is also the only way to record a premature exit.

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

Specifies that the default behavior should be used.

A hint to a TaskScheduler to schedule a task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to be run sooner, and tasks scheduled later will be more likely to be run later.

Specifies that a task will be a long-running, course-grained operation. It provides a hint to the TaskScheduler that oversubscription may be warranted.

Specifies that a task is attached to a parent in the task hierarchy.

Task creation flags which are only used internally.

Specifies "No internal task options"

Used to filter out internal vs. public task creation options.

Specifies that the task will be queued by the runtime before handing it over to the user. This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks.

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

Default = "Continue on any, no task options, run asynchronously" Specifies that the default behavior should be used. Continuations, by default, will be scheduled when the antecedent task completes, regardless of the task's final TaskStatus.

Specifies that a task will be a long-running, course-grained operation. It provides a hint to the TaskScheduler that oversubscription may be warranted.

Specifies that a task is attached to a parent in the task hierarchy.

Specifies that the continuation task should not be scheduled if its antecedent ran to completion. This option is not valid for multi-task continuations.

Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled exception. This option is not valid for multi-task continuations.

Specifies that the continuation task should not be scheduled if its antecedent was canceled. This option is not valid for multi-task continuations.

Specifies that the continuation task should be scheduled only if its antecedent ran to completion. This option is not valid for multi-task continuations.

Specifies that the continuation task should be scheduled only if its antecedent threw an unhandled exception. This option is not valid for multi-task continuations.

Specifies that the continuation task should be scheduled only if its antecedent was canceled. This option is not valid for multi-task continuations.

Specifies that the continuation task should be executed synchronously. With this option specified, the continuation will be run on the same thread that causes the antecedent task to transition into its final state. If the antecedent is already complete when the continuation is created, the continuation will run on the thread creating the continuation. Only very short-running continuations should be executed synchronously.

Internal helper class to keep track of stack depth and decide whether we should inline or not.

This method needs to be called before attempting inline execution on the current thread. If false is returned, it means we are too close to the end of the stack and should give up inlining. Each call to TryBeginInliningScope() that returns true must be matched with a call to EndInliningScope() regardless of whether inlining actually took place.

This needs to be called once for each previous successful TryBeginInliningScope() call after inlining related logic runs.

Represents an exception used to communicate task cancellation.

Initializes a new instance of the class.

Initializes a new instance of the class with a specified error message.

The error message that explains the reason for the exception.

Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception.

The error message that explains the reason for the exception. The exception that is the cause of the current exception.

Initializes a new instance of the class with a reference to the that has been canceled.

A task that has been canceled.

Initializes a new instance of the class with serialized data.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination.

Gets the task associated with this exception.

It is permissible for no Task to be associated with a , in which case this property will return null.

An exception holder manages a list of exceptions for one particular task. It offers the ability to aggregate, but more importantly, also offers intrinsic support for propagating unhandled exceptions that are never observed. It does this by aggregating and throwing if the holder is ever GC'd without the holder's contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc).

Creates a new holder; it will be registered for finalization.

The task this holder belongs to.

A finalizer that repropagates unhandled exceptions.

Add an exception to the internal list. This will ensure the holder is in the proper state (handled/unhandled) depending on the list's contents.

An exception object (either an Exception or an IEnumerable{Exception}) to add to the list.

A private helper method that ensures the holder is considered unhandled, i.e. it is registered for finalization.

A private helper method that ensures the holder is considered handled, i.e. it is not registered for finalization.

Whether this is called from the finalizer thread.

Allocates a new aggregate exception and adds the contents of the list to it. By calling this method, the holder assumes exceptions to have been "observed", such that the finalization check will be subsequently skipped.

Whether this is being called from a finalizer. An extra exception to be included (optionally). The aggregate exception to throw.

Provides support for creating and scheduling Tasks.

There are many common patterns for which tasks are relevant. The class encodes some of these patterns into methods that pick up default settings, which are configurable through its constructors. A default instance of is available through the Task.Factory property.

Initializes a instance with the default configuration.

Initializes a instance with the specified configuration.

The TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value indicates that the current TaskScheduler should be used. With this constructor, the property is initialized to TaskCreationOptions.None, the property is initialized to TaskContinuationOptions.None, and the TaskScheduler property is initialized to , unless it's null, in which case the property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the specified configuration.

The default TaskCreationOptions to use when creating tasks with this TaskFactory. The default TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. The exception that is thrown when the argument or the argument specifies an invalid value. With this constructor, the property is initialized to , the property is initialized to , and the TaskScheduler property is initialized to the current scheduler (see TaskScheduler.Current).

Initializes a instance with the specified configuration.

The default that will be assigned to tasks created by this unless another CancellationToken is explicitly specified while calling the factory methods. The default TaskCreationOptions to use when creating tasks with this TaskFactory. The default TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. The default TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value indicates that TaskScheduler.Current should be used. The exception that is thrown when the argument or the argumentspecifies an invalid value. With this constructor, the property is initialized to , the property is initialized to , and the TaskScheduler property is initialized to , unless it's null, in which case the property is initialized to the current scheduler (see TaskScheduler.Current).

Creates and starts a Task.

The action delegate to execute asynchronously. The started Task. The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. The that will be assigned to the new task. The started Task. The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. A TaskCreationOptions value that controls the behavior of the created Task. The started Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. The that will be assigned to the new A TaskCreationOptions value that controls the behavior of the created Task. The TaskScheduler that is used to schedule the created Task. The started Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. An object containing data to be used by the delegate. The started Task. The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. An object containing data to be used by the delegate. The that will be assigned to the new The started Task. The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. An object containing data to be used by the delegate. A TaskCreationOptions value that controls the behavior of the created Task. The started Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a Task.

The action delegate to execute asynchronously. An object containing data to be used by the delegate. The that will be assigned to the new task. A TaskCreationOptions value that controls the behavior of the created Task. The TaskScheduler that is used to schedule the created Task. The started Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a Task using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . The started . The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . The that will be assigned to the new The started . The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . A TaskCreationOptions value that controls the behavior of the created . The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . The that will be assigned to the new task. A TaskCreationOptions value that controls the behavior of the created . The TaskScheduler that is used to schedule the created Task{TResult}. The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The started . The exception that is thrown when the argument is null. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The that will be assigned to the new The started . The exception that is thrown when the argument is null. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. A TaskCreationOptions value that controls the behavior of the created . The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates and starts a .

The type of the result available through the Task. A function delegate that returns the future result to be available through the . An object containing data to be used by the delegate. The that will be assigned to the new task. A TaskCreationOptions value that controls the behavior of the created . The TaskScheduler that is used to schedule the created Task{TResult}. The started . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The provided CancellationToken has already been disposed. Calling StartNew is functionally equivalent to creating a using one of its constructors and then calling Start to schedule it for execution. However, unless creation and scheduling must be separated, StartNew is the recommended approach for both simplicity and performance.

Creates a Task that executes an end method action when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The action delegate that processes the completed . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. A Task that represents the asynchronous operation.

Creates a Task that executes an end method action when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The action delegate that processes the completed . The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that executes an end method action when a specified IAsyncResult completes.

The IAsyncResult whose completion should trigger the processing of the . The action delegate that processes the completed . The TaskScheduler that is used to schedule the task that executes the end method. The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the third argument passed to delegate. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The third argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The type of the result available through the Task. The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. A Task that represents the asynchronous operation.

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The type of the result available through the Task. The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that executes an end method function when a specified IAsyncResult completes.

The type of the result available through the Task. The IAsyncResult whose completion should trigger the processing of the . The function delegate that processes the completed . The TaskScheduler that is used to schedule the task that executes the end method. The TaskCreationOptions value that controls the behavior of the created Task. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. A Task that represents the asynchronous operation.

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the third argument passed to delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The third argument passed to the delegate. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.

The type of the first argument passed to the delegate. The type of the second argument passed to delegate. The type of the third argument passed to delegate. The type of the result available through the Task. The delegate that begins the asynchronous operation. The delegate that ends the asynchronous operation. The first argument passed to the delegate. The second argument passed to the delegate. The third argument passed to the delegate. The TaskCreationOptions value that controls the behavior of the created Task. An object containing data to be used by the delegate. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument specifies an invalid TaskCreationOptions value. The created Task that represents the asynchronous operation. This method throws any exceptions thrown by the .

Check validity of options passed to FromAsync method

The options to be validated. determines type of FromAsync method that called this method

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result of the antecedent . The array of tasks from which to continue. The action delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result that is returned by the delegate and associated with the created . The type of the result of the antecedent . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of a set of provided Tasks.

The type of the result that is returned by the delegate and associated with the created . The type of the result of the antecedent . The array of tasks from which to continue. The function delegate to execute when all tasks in the array have completed. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAll.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation Task. The new continuation Task. The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result that is returned by the delegate and associated with the created . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result that is returned by the delegate and associated with the created . The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result that is returned by the delegate and associated with the created . The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The function delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when one of the elements in the array has been disposed.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

The type of the result of the antecedent . The array of tasks from which to continue when one task completes. The action delegate to execute when one task in the array completes. The CancellationToken that will be assigned to the new continuation task. The TaskContinuationOptions value that controls the behavior of the created continuation Task. The TaskScheduler that is used to schedule the created continuation . The new continuation . The exception that is thrown when the array is null. The exception that is thrown when the argument is null. The exception that is thrown when the argument is null. The exception that is thrown when the array contains a null value. The exception that is thrown when the array is empty. The exception that is thrown when the argument specifies an invalid TaskContinuationOptions value. The exception that is thrown when one of the elements in the array has been disposed. The provided CancellationToken has already been disposed. The NotOn* and OnlyOn* TaskContinuationOptions, which constrain for which TaskStatus states a continuation will be executed, are illegal with ContinueWhenAny.

Gets the default CancellationToken of this TaskFactory.

This property returns the default that will be assigned to all tasks created by this factory unless another CancellationToken value is explicitly specified during the call to the factory methods.

Gets the TaskScheduler of this TaskFactory.

Gets the TaskCreationOptions value of this TaskFactory.

This property returns the default creation options for this factory. They will be used to create all tasks unless other options are explicitly specified during calls to this factory's methods.

Gets the TaskContinuationOptions value of this TaskFactory.

Represents the producer side of a unbound to a delegate, providing access to the consumer side through the property.

It is often the case that a is desired to represent another asynchronous operation. TaskCompletionSource is provided for this purpose. It enables the creation of a task that can be handed out to consumers, and those consumers can use the members of the task as they would any other. However, unlike most tasks, the state of a task created by a TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the completion of the external asynchronous operation to be propagated to the underlying Task. The separation also ensures that consumers are not able to transition the state without access to the corresponding TaskCompletionSource. All members of are thread-safe and may be used from multiple threads concurrently. The type of the result value assocatied with this .

Creates a .

Creates a with the specified options.

The created by this instance and accessible through its property will be instantiated using the specified . The options to use when creating the underlying . The represent options invalid for use with a .

Creates a with the specified state.

The state to use as the underlying 's AsyncState.

Creates a with the specified state and options.

The options to use when creating the underlying . The state to use as the underlying 's AsyncState. The represent options invalid for use with a .

Attempts to transition the underlying into the Faulted state.

The exception to bind to this . True if the operation was successful; otherwise, false. This operation will return false if the is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The argument is null. The was disposed.

Attempts to transition the underlying into the Faulted state.

The collection of exceptions to bind to this . True if the operation was successful; otherwise, false. This operation will return false if the is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The argument is null. There are one or more null elements in . The collection is empty. The was disposed.

Transitions the underlying into the Faulted state.

The exception to bind to this . The argument is null. The underlying is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Transitions the underlying into the Faulted state.

The collection of exceptions to bind to this . The argument is null. There are one or more null elements in . The underlying is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Attempts to transition the underlying into the RanToCompletion state.

The result value to bind to this . True if the operation was successful; otherwise, false. This operation will return false if the is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Transitions the underlying into the RanToCompletion state.

The result value to bind to this . The underlying is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Transitions the underlying into the Canceled state.

The underlying is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Attempts to transition the underlying into the Canceled state.

True if the operation was successful; otherwise, false. This operation will return false if the is already in one of the three final states: RanToCompletion, Faulted, or Canceled. The was disposed.

Gets the created by this .

This property enables a consumer access to the that is controlled by this instance. The , , , and methods (and their "Try" variants) on this instance all result in the relevant state transitions on this underlying Task.

Represents an abstract scheduler for tasks.

TaskScheduler acts as the extension point for all pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and how scheduled tasks should be exposed to debuggers. All members of the abstract type are thread-safe and may be used from multiple threads concurrently.

Queues a Task to the scheduler.

A class derived from TaskScheduler implements this method to accept tasks being scheduled on the scheduler. A typical implementation would store the task in an internal data structure, which would be serviced by threads that would execute those tasks at some time in the future. This method is only meant to be called by the .NET Framework and should not be called directly by the derived class. This is necessary for maintaining the consistency of the system. The Task to be queued. The argument is null.

Determines whether the provided Task can be executed synchronously in this call, and if it can, executes it.

A class derived from TaskScheduler implements this function to support inline execution of a task on a thread that initiates a wait on that task object. Inline execution is optional, and the request may be rejected by returning false. However, better scalability typically results the more tasks that can be inlined, and in fact a scheduler that inlines too little may be prone to deadlocks. A proper implementation should ensure that a request executing under the policies guaranteed by the scheduler can successfully inline. For example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that thread should succeed. If a scheduler decides to perform the inline execution, it should do so by calling to the base TaskScheduler's TryExecuteTask method with the provided task object, propagating the return value. It may also be appropriate for the scheduler to remove an inlined task from its internal data structures if it decides to honor the inlining request. Note, however, that under some circumstances a scheduler may be asked to inline a task that was not previously provided to it with the method. The derived scheduler is responsible for making sure that the calling thread is suitable for executing the given task as far as its own scheduling and execution policies are concerned. The Task to be executed. A Boolean denoting whether or not task has previously been queued. If this parameter is True, then the task may have been previously queued (scheduled); if False, then the task is known not to have been queued, and this call is being made in order to execute the task inline without queueing it. A Boolean value indicating whether the task was executed inline. The argument is null. The was already executed.

Generates an enumerable of Task instances currently queued to the scheduler waiting to be executed.

A class derived from implements this method in order to support integration with debuggers. This method will only be invoked by the .NET Framework when the debugger requests access to the data. The enumerable returned will be traversed by debugging utilities to access the tasks currently queued to this scheduler, enabling the debugger to provide a representation of this information in the user interface. It is important to note that, when this method is called, all other threads in the process will be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to blocking. If synchronization is necessary, the method should prefer to throw a than to block, which could cause a debugger to experience delays. Additionally, this method and the enumerable returned must not modify any globally visible state. The returned enumerable should never be null. If there are currently no queued tasks, an empty enumerable should be returned instead. For developers implementing a custom debugger, this method shouldn't be called directly, but rather this functionality should be accessed through the internal wrapper method GetScheduledTasksForDebugger: internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). This static method returns an array of all active TaskScheduler instances. GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve the list of scheduled tasks for each. An enumerable that allows traversal of tasks currently queued to this scheduler. This scheduler is unable to generate a list of queued tasks at this time.

Retrieves some thread static state that can be cached and passed to multiple TryRunInline calls, avoiding superflous TLS fetches.

A bag of TLS state (or null if none exists).

Attempts to execute the target task synchronously.

The task to run. True if the task may have been previously queued, false if the task was absolutely not previously queued. The state retrieved from GetThreadStatics True if it ran, false otherwise.

Attempts to dequeue a Task that was previously queued to this scheduler.

The Task to be dequeued. A Boolean denoting whether the argument was successfully dequeued. The argument is null.

Notifies the scheduler that a work item has made progress.

Initializes the .

Frees all resources associated with this scheduler.

Creates a associated with the current .

All Task instances queued to the returned scheduler will be executed through a call to the Post method on that context. A associated with the current SynchronizationContext, as determined by SynchronizationContext.Current. The current SynchronizationContext may not be used as a TaskScheduler.

Attempts to execute the provided Task on this scheduler.

Scheduler implementations are provided with Task instances to be executed through either the method or the method. When the scheduler deems it appropriate to run the provided task, should be used to do so. TryExecuteTask handles all aspects of executing a task, including action invocation, exception handling, state management, and lifecycle control. must only be used for tasks provided to this scheduler by the .NET Framework infrastructure. It should not be used to execute arbitrary tasks obtained through custom mechanisms. A Task object to be executed. The is not associated with this scheduler. A Boolean that is true if was successfully executed, false if it was not. A common reason for execution failure is that the task had previously been executed or is in the process of being executed by another thread.

Provides an array of all queued Task instances for the debugger.

The returned array is populated through a call to . Note that this function is only meant to be invoked by a debugger remotely. It should not be called by any other codepaths. An array of Task instances. This scheduler is unable to generate a list of queued tasks at this time.

Provides an array of all active TaskScheduler instances for the debugger.

This function is only meant to be invoked by a debugger remotely. It should not be called by any other codepaths. An array of TaskScheduler instances.

Registers a new TaskScheduler instance in the global collection of schedulers.

Removes a TaskScheduler instance from the global collection of schedulers.

Indicates the maximum concurrency level this is able to support.

Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry using a CAS to transition from queued state to executing.

Gets the default TaskScheduler instance.

Gets the TaskScheduler associated with the currently executing task.

When not called from within a task, will return the scheduler.

Gets the unique ID for this .

Occurs when a faulted 's unobserved exception is about to trigger exception escalation policy, which, by default, would terminate the process.

This AppDomain-wide event provides a mechanism to prevent exception escalation policy (which, by default, terminates the process) from triggering. Each handler is passed a instance, which may be used to examine the exception and to mark it as observed.

Nested class that provides debugger view for TaskScheduler

A TaskScheduler implementation that executes all tasks queued to it through a call to on the that its associated with. The default constructor for this class binds to the current

Constructs a SynchronizationContextTaskScheduler associated with

This constructor expects to be set.

Implemetation of for this scheduler class. Simply posts the tasks to be executed on the associated .

Implementation of for this scheduler class. The task will be executed inline only if the call happens within the associated .

Implementes the property for this scheduler class. By default it returns 1, because a based scheduler only supports execution on a single thread.

Provides data for the event that is raised when a faulted 's exception goes unobserved.

The Exception property is used to examine the exception without marking it as observed, whereas the method is used to mark the exception as observed. Marking the exception as observed prevents it from triggering exception escalation policy which, by default, terminates the process.

Initializes a new instance of the class with the unobserved exception.

The Exception that has gone unobserved.

Marks the as "observed," thus preventing it from triggering exception escalation policy which, by default, terminates the process.

Gets whether this exception has been marked as "observed."

The Exception that went unobserved.

An implementation of TaskScheduler that uses the ThreadPool scheduler

Constructs a new ThreadPool task scheduler object

Schedules a task to the ThreadPool.

The task to schedule.

This internal function will do this: (1) If the task had previously been queued, attempt to pop it and return false if that fails. (2) Propagate the return value from Task.ExecuteEntry() back to the caller. IMPORTANT NOTE: TryExecuteTaskInline will NOT throw task exceptions itself. Any wait code path using this function needs to account for exceptions that need to be propagated, and throw themselves accordingly.

Notifies the scheduler that work is progressing (no-op).

This is the only scheduler that returns false for this property, indicating that the task entry codepath is unsafe (CAS free) since we know that the underlying scheduler already takes care of atomic transitions from queued to non-queued.

Represents an exception used to communicate an invalid operation by a .

Initializes a new instance of the class.

Initializes a new instance of the class with a specified error message.

The error message that explains the reason for the exception.

Initializes a new instance of the class using the default error message and a reference to the inner exception that is the cause of this exception.

The exception that is the cause of the current exception.

Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception.

The error message that explains the reason for the exception. The exception that is the cause of the current exception.

Initializes a new instance of the class with serialized data.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination.

The exception that is thrown when the post-phase action of a fails.

Initializes a new instance of the class.

Initializes a new instance of the class with the specified inner exception.

The exception that is the cause of the current exception.

Initializes a new instance of the class with a specified error message.

A string that describes the exception.

Initializes a new instance of the class with a specified error message and inner exception.

A string that describes the exception. The exception that is the cause of the current exception.

Initializes a new instance of the class with serialized data.

The object that holds the serialized object data. An object that describes the source or destination of the serialized data.

Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases.

A group of tasks cooperate by moving through a series of phases, where each in the group signals it has arrived at the in a given phase and implicitly waits for all others to arrive. The same can be used for multiple phases. All public and protected members of are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the have completed.

Initializes a new instance of the class.

The number of participating threads. is less than 0 or greater than .

Initializes a new instance of the class.

The number of participating threads. The to be executed after each phase. is less than 0 or greater than . The delegate will be executed after all participants have arrived at the barrier in one phase. The participants will not be released to the next phase until the postPhaseAction delegate has completed execution.

Extract the three variables current, total and sense from a given big variable

The integer variable that contains the other three variables The current cparticipant count The total participants count The sense flag

Write the three variables current. total and the sense to the m_currentTotal

The old current total to compare The current cparticipant count The total participants count The sense flag True if the CAS succeeded, false otherwise

Notifies the that there will be an additional participant.

The phase number of the barrier in which the new participants will first participate. Adding a participant would cause the barrier's participant count to exceed . The method was invoked from within a post-phase action. The current instance has already been disposed.

Notifies the that there will be additional participants.

The number of additional participants to add to the barrier. The phase number of the barrier in which the new participants will first participate. is less than 0. Adding participants would cause the barrier's participant count to exceed . The method was invoked from within a post-phase action. The current instance has already been disposed.

Notifies the that there will be one less participant.

The barrier already has 0 participants. The method was invoked from within a post-phase action. The current instance has already been disposed.

Notifies the that there will be fewer participants.

The number of additional participants to remove from the barrier. is less than 0. The barrier already has 0 participants. The method was invoked from within a post-phase action. The current instance has already been disposed.

Signals that a participant has reached the and waits for all other participants to reach the barrier as well.

The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. The current instance has already been disposed.

Signals that a participant has reached the and waits for all other participants to reach the barrier, while observing a .

The to observe. The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. has been canceled. The current instance has already been disposed.

Signals that a participant has reached the and waits for all other participants to reach the barrier as well, using a to measure the time interval.

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if all other participants reached the barrier; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out, or it is greater than . The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. The current instance has already been disposed.

Signals that a participant has reached the and waits for all other participants to reach the barrier as well, using a to measure the time interval, while observing a .

A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The to observe. true if all other participants reached the barrier; otherwise, false. is a negative number other than -1 milliseconds, which represents an infinite time-out. The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. has been canceled. The current instance has already been disposed.

Signals that a participant has reached the and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the time interval.

The number of milliseconds to wait, or (-1) to wait indefinitely. true if all other participants reached the barrier; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. The current instance has already been disposed.

Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the time interval, while observing a .

The number of milliseconds to wait, or (-1) to wait indefinitely. The to observe. true if all other participants reached the barrier; otherwise, false. is a negative number other than -1, which represents an infinite time-out. The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is being used by more threads than are registered as participants. has been canceled. The current instance has already been disposed.

Finish the phase by invoking the post phase action, and setting the event, this must be called by the last arrival thread

The current phase sense

Sets the current phase event and reset the next phase event

The current phase sense

Releases all resources used by the current instance of .

The method was invoked from within a post-phase action. Unlike most of the members of , Dispose is not thread-safe and may not be used concurrently with other members of this instance.

When overridden in a derived class, releases the unmanaged resources used by the , and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources. Unlike most of the members of , Dispose is not thread-safe and may not be used concurrently with other members of this instance.

Throw ObjectDisposedException if the barrier is disposed

Gets the number of participants in the barrier that haven’t yet signaled in the current phase.

This could be 0 during a post-phase action delegate execution or if the ParticipantCount is 0.

Gets the total number of participants in the barrier.

Gets the number of the barrier's current phase.

Provides blocking and bounding capabilities for thread-safe collections that implement .

represents a collection that allows for thread-safe adding and removing of data. is used as a wrapper for an instance, allowing removal attempts from the collection to block until data is available to be removed. Similarly, a can be created to enforce an upper-bound on the number of data elements allowed in the ; addition attempts to the collection may then block until space is available to store the added items. In this manner, is similar to a traditional blocking queue data structure, except that the underlying data storage mechanism is abstracted away as an . Specifies the type of elements in the collection.

Initializes a new instance of the class without an upper-bound.

The default underlying collection is a ConcurrentQueue<T>.

Initializes a new instance of the class with the specified upper-bound.

The bounded size of the collection. The is not a positive value. The default underlying collection is a ConcurrentQueue<T>.

Initializes a new instance of the class with the specified upper-bound and using the provided as its underlying data store.

The collection to use as the underlying data store. The bounded size of the collection. The argument is null. The is not a positive value. The supplied contains more values than is permitted by .

Initializes a new instance of the class without an upper-bound and using the provided as its underlying data store.

The collection to use as the underlying data store. The argument is null.

Initializes the BlockingCollection instance.

The collection to use as the underlying data store. The bounded size of the collection. The number of items currently in the underlying collection.

Adds the item to the .

The item to be added to the collection. The value can be a null reference. The has been marked as complete with regards to additions. The has been disposed. The underlying collection didn't accept the item. If a bounded capacity was specified when this instance of was initialized, a call to Add may block until space is available to store the provided item.

Adds the item to the . A is thrown if the is canceled.

The item to be added to the collection. The value can be a null reference. A cancellation token to observe. If the is canceled. The has been marked as complete with regards to additions. The has been disposed. The underlying collection didn't accept the item. If a bounded capacity was specified when this instance of was initialized, a call to may block until space is available to store the provided item.

Attempts to add the specified item to the .

The item to be added to the collection. true if the could be added; otherwise, false. The has been marked as complete with regards to additions. The has been disposed. The underlying collection didn't accept the item.

Attempts to add the specified item to the .

The item to be added to the collection. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if the could be added to the collection within the alloted time; otherwise, false. The has been marked as complete with regards to additions. The has been disposed. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The underlying collection didn't accept the item.

Attempts to add the specified item to the .

The item to be added to the collection. The number of milliseconds to wait, or (-1) to wait indefinitely. true if the could be added to the collection within the alloted time; otherwise, false. The has been marked as complete with regards to additions. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The underlying collection didn't accept the item.

Attempts to add the specified item to the . A is thrown if the is canceled.

The item to be added to the collection. The number of milliseconds to wait, or (-1) to wait indefinitely. A cancellation token to observe. true if the could be added to the collection within the alloted time; otherwise, false. If the is canceled. The has been marked as complete with regards to additions. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The underlying collection didn't accept the item.

Adds an item into the underlying data store using its IProducerConsumerCollection<T>.Add method. If a bounded capacity was specified and the collection was full, this method will wait for, at most, the timeout period trying to add the item. If the timeout period was exhaused before successfully adding the item this method will return false.

The item to be added to the collection. The number of milliseconds to wait for the collection to accept the item, or Timeout.Infinite to wait indefinitely. A cancellation token to observe. False if the collection remained full till the timeout period was exhausted.True otherwise. If the is canceled. the collection has already been marked as complete with regards to additions. If the collection has been disposed. The underlying collection didn't accept the item.

Takes an item from the .

The item removed from the collection. The is empty and has been marked as complete with regards to additions. The has been disposed. The underlying collection was modified outside of this instance. A call to may block until an item is available to be removed.

Takes an item from the .

The item removed from the collection. If the is canceled or the is empty and has been marked as complete with regards to additions. The has been disposed. The underlying collection was modified outside of this instance. A call to may block until an item is available to be removed.

Attempts to remove an item from the .

The item removed from the collection. true if an item could be removed; otherwise, false. The has been disposed. The underlying collection was modified outside of this instance.

Attempts to remove an item from the .

The item removed from the collection. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. true if an item could be removed from the collection within the alloted time; otherwise, false. The has been disposed. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The underlying collection was modified outside of this instance.

Attempts to remove an item from the .

The item removed from the collection. The number of milliseconds to wait, or (-1) to wait indefinitely. true if an item could be removed from the collection within the alloted time; otherwise, false. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The underlying collection was modified outside of this instance.

Attempts to remove an item from the . A is thrown if the is canceled.

The item removed from the collection. The number of milliseconds to wait, or (-1) to wait indefinitely. A cancellation token to observe. true if an item could be removed from the collection within the alloted time; otherwise, false. If the is canceled. The has been disposed. is a negative number other than -1, which represents an infinite time-out. The underlying collection was modified outside of this instance.

Takes an item from the underlying data store using its IProducerConsumerCollection<T>.Take method. If the collection was empty, this method will wait for, at most, the timeout period (if AddingIsCompleted is false) trying to remove an item. If the timeout period was exhaused before successfully removing an item this method will return false. A is thrown if the is canceled.

The item removed from the collection. The number of milliseconds to wait for the collection to have an item available for removal, or Timeout.Infinite to wait indefinitely. A cancellation token to observe. A combined cancellation token if created, it is only created by GetConsumingEnumerable to avoid creating the linked token multiple times. False if the collection remained empty till the timeout period was exhausted. True otherwise. If the is canceled. If the collection has been disposed.

Adds the specified item to any one of the specified instances.

The array of collections. The item to be added to one of the collections. The index of the collection in the array to which the item was added. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA. If a bounded capacity was specified when all of the instances were initialized, a call to AddToAny may block until space is available in one of the collections to store the provided item.

Adds the specified item to any one of the specified instances. A is thrown if the is canceled.

The array of collections. The item to be added to one of the collections. A cancellation token to observe. The index of the collection in the array to which the item was added. If the is canceled. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA. If a bounded capacity was specified when all of the instances were initialized, a call to AddToAny may block until space is available in one of the collections to store the provided item.

Attempts to add the specified item to any one of the specified instances.

The array of collections. The item to be added to one of the collections. The index of the collection in the array to which the item was added, or -1 if the item could not be added. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA.

Attempts to add the specified item to any one of the specified instances.

The array of collections. The item to be added to one of the collections. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The index of the collection in the array to which the item was added, or -1 if the item could not be added. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA.

Attempts to add the specified item to any one of the specified instances.

The array of collections. The item to be added to one of the collections. The number of milliseconds to wait, or (-1) to wait indefinitely. /// The index of the collection in the array to which the item was added, or -1 if the item could not be added. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. is a negative number other than -1, which represents an infinite time-out. At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA.

Attempts to add the specified item to any one of the specified instances. A is thrown if the is canceled.

The array of collections. The item to be added to one of the collections. The number of milliseconds to wait, or (-1) to wait indefinitely. /// The index of the collection in the array to which the item was added, or -1 if the item could not be added. A cancellation token to observe. If the is canceled. The argument is null. The argument is a 0-length array or contains a null element, or at least one of collections has been marked as complete for adding. At least one of the instances has been disposed. is a negative number other than -1, which represents an infinite time-out. At least one underlying collection didn't accept the item. The count of is greater than the maximum size of 62 for STA and 63 for MTA.

Adds/Takes an item to/from anyone of the specified collections. A is thrown if the is canceled.

The collections into which the item can be added. The item to be added or the item removed and returned to the caller. The number of milliseconds to wait for a collection to accept the operation, or -1 to wait indefinitely. Indicates whether this method is called to Add or Take. A cancellation token to observe. The index into collections for the collection which accepted the adding/removal of the item; -1 if the item could not be added/removed. If the is canceled. If the collections argument is null. If the collections argument is a 0-length array or contains a null element. Also, if atleast one of the collections has been marked complete for adds. If atleast one of the collections has been disposed.

Local static method, used by TryAddTakeAny to get the wait handles for the collection, with exclude option to exclude the Compeleted collections

The blocking collections Add or Take operation The original CancellationToken True to exclude the compeleted collections Complete list of cancellationTokens to observe The collections wait handles

Helper to perform WaitHandle.WaitAny(.., CancellationToken) this should eventually appear on the WaitHandle class.

Helper function to measure and update the wait time

The first time (in Ticks) observed when the wait started The orginal wait timeoutout in milliseconds The new wait time in milliseconds, -1 if the time expired

Takes an item from any one of the specified instances.

The array of collections. The item removed from one of the collections. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. The argument is null. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TakeFromAny may block until an item is available to be removed.

Takes an item from any one of the specified instances. A is thrown if the is canceled.

The array of collections. The item removed from one of the collections. A cancellation token to observe. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. The argument is null. If the is canceled. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TakeFromAny may block until an item is available to be removed.

Attempts to remove an item from any one of the specified instances.

The array of collections. The item removed from one of the collections. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. The argument is null. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TryTakeFromAny may block until an item is available to be removed.

Attempts to remove an item from any one of the specified instances.

The array of collections. The item removed from one of the collections. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. The argument is null. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TryTakeFromAny may block until an item is available to be removed.

Attempts to remove an item from any one of the specified instances.

The array of collections. The item removed from one of the collections. The number of milliseconds to wait, or (-1) to wait indefinitely. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. The argument is null. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. is a negative number other than -1, which represents an infinite time-out. At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TryTakeFromAny may block until an item is available to be removed.

Attempts to remove an item from any one of the specified instances. A is thrown if the is canceled.

The array of collections. The item removed from one of the collections. The number of milliseconds to wait, or (-1) to wait indefinitely. A cancellation token to observe. The index of the collection in the array from which the item was removed, or -1 if an item could not be removed. If the is canceled. The argument is null. The argument is a 0-length array or contains a null element. At least one of the instances has been disposed. is a negative number other than -1, which represents an infinite time-out. At least one of the underlying collections was modified outside of its instance. The count of is greater than the maximum size of 62 for STA and 63 for MTA. A call to TryTakeFromAny may block until an item is available to be removed.

Marks the instances as not accepting any more additions.

After a collection has been marked as complete for adding, adding to the collection is not permitted and attempts to remove from the collection will not wait when the collection is empty. The has been disposed.

Cancels the semaphores.

Releases resources used by the instance.

Whether being disposed explicitly (true) or due to a finalizer (false).

Copies the items from the instance into a new array.

An array containing copies of the elements of the collection. The has been disposed. The copied elements are not removed from the collection.

Copies all of the items in the instance to a compatible one-dimensional array, starting at the specified index of the target array.

The one-dimensional array that is the destination of the elements copied from the instance. The array must have zero-based indexing. The zero-based index in at which copying begins. The argument is null. The argument is less than zero. The argument is equal to or greater than the length of the , the array is multidimensional, or the type parameter for the collection cannot be cast automatically to the type of the destination array. The has been disposed.

Provides a consuming for items in the collection.

An that removes and returns items from the collection. The has been disposed.

Provides a consuming for items in the collection. Calling MoveNext on the returned enumerable will block if there is no data available, or will throw an if the is canceled.

A cancellation token to observe. An that removes and returns items from the collection. The has been disposed. If the is canceled.

Provides an for items in the collection.

An for the items in the collection. The has been disposed.

Provides an for items in the collection.

An for the items in the collection. The has been disposed.

Centralizes the logic for validating the BlockingCollections array passed to TryAddToAny() and TryTakeFromAny().

The collections to/from which an item should be added/removed. Indicates whether this method is called to Add or Take. A copy of the collections array that acts as a defense to prevent an “outsider” from changing elements of the array after we have done the validation on them. If the collections argument is null. If the collections argument is a 0-length array or contains a null element. Also, if atleast one of the collections has been marked complete for adds. If atleast one of the collections has been disposed.

Centeralizes the logic of validating the timeout input argument.

The TimeSpan to wait for to successfully complete an operation on the collection. If the number of millseconds represented by the timeout TimeSpan is less than 0 or is larger than Int32.MaxValue and not Timeout.Infinite

Centralizes the logic of validating the millisecondsTimeout input argument.

The number of milliseconds to wait for to successfully complete an operation on the collection. If the number of millseconds is less than 0 and not equal to Timeout.Infinite.

Throws a System.ObjectDisposedException if the collection was disposed

If the collection has been disposed.

Gets the bounded capacity of this instance.

The bounded capacity of this collection, or int.MaxValue if no bound was supplied. The has been disposed.

Gets whether this has been marked as complete for adding.

Whether this collection has been marked as complete for adding. The has been disposed.

Gets whether this has been marked as complete for adding and is empty.

Whether this collection has been marked as complete for adding and is empty. The has been disposed.

Gets the number of items contained in the .

The number of items contained in the . The has been disposed.

Gets a value indicating whether access to the is synchronized.

The has been disposed.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

An enumerated data type used internal to the class to specify to a generic method the current mode of operation.

A debugger view of the blocking collection that makes it simple to browse the collection's contents at a point in time.

The type of element that the BlockingCollection will hold.

Constructs a new debugger view object for the provided blocking collection object.

A blocking collection to browse in the debugger.

Returns a snapshot of the underlying collection's elements.

Represents an thread-safe, unordered collection of objects.

Specifies the type of elements in the bag. Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support duplicates. is a thread-safe bag implementation, optimized for scenarios where the same thread will be both producing and consuming data stored in the bag. accepts null reference (Nothing in Visual Basic) as a valid value for reference types. All public and protected members of are thread-safe and may be used concurrently from multiple threads.

Initializes a new instance of the class.

Initializes a new instance of the class that contains elements copied from the specified collection.

The collection whose elements are copied to the new . is a null reference (Nothing in Visual Basic).

Local helper function to initalize a new bag object

An enumeration containing items with which to initialize this bag.

Adds an object to the .

The object to be added to the . The value can be a null reference (Nothing in Visual Basic) for reference types.

Attempts to add an object to the .

The object to be added to the . The value can be a null reference (Nothing in Visual Basic) for reference types. Always returns true

Attempts to remove and return an object from the .

When this method returns, contains the object removed from the or the default value of if the operation failed. true if an object was removed successfully; otherwise, false.

Attempts to return an object from the without removing it.

When this method returns, contains an object from the or the default value of if the operation failed. true if and object was returned successfully; otherwise, false.

Local helper function to Take or Peek an item from the bag

To receive the item retrieved from the bag True means Take operation, false means Peek operation True if succeeded, false otherwise

Local helper function to retrieve a thread local list by a thread object

Create a new list if the thread does ot exist The local list object

Try to reuse an unowned list if exist unowned lists are the lists that their owner threads are aborted or terminated this is workaround to avoid memory leaks.

The list object, null if all lists are owned

Local helper method to steal an item from any other non empty thread It enumerate all other threads in two passes first pass acquire the lock with TryEnter if succeeded it steals the item, otherwise it enumerate them again in 2nd pass and acquire the lock using Enter

To receive the item retrieved from the bag Whether to remove or peek. True if succeeded, false otherwise.

local helper function tries to steal an item from given local list

Local helper function to check the list if it became empty after acquiring the lock and wait if there is unsynchronized Add/Take operation in the list to be done

The list to steal True if can steal, false otherwise

Copies the elements to an existing one-dimensional Array, starting at the specified array index.

The one-dimensional Array that is the destination of the elements copied from the . The Array must have zero-based indexing. The zero-based index in at which copying begins. is a null reference (Nothing in Visual Basic). is less than zero. is equal to or greater than the length of the -or- the number of elements in the source is greater than the available space from to the end of the destination .

Copies the elements of the to an , starting at a particular index.

Copies the elements to a new array.

A new array containing a snapshot of elements copied from the .

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The enumeration represents a moment-in-time snapshot of the contents of the bag. It does not reflect any updates to the collection after was called. The enumerator is safe to use concurrently with reads from and writes to the bag.

Returns an enumerator that iterates through the .

An enumerator for the contents of the . The items enumerated represent a moment-in-time snapshot of the contents of the bag. It does not reflect any update to the collection after was called.

Get the data array to be serialized

Construct the stack from a previously seiralized one

Local helper method to freeze all bag operations, it 1- Acquire the global lock to prevent any other thread to freeze the bag, and also new new thread can be added to the dictionary 2- Then Acquire all local lists locks to prevent steal and synchronized operations 3- Wait for all un-synchronized operations to be done

Retrieve the lock taken result for the global lock, to be passed to Unfreeze method

Local helper method to unfreeze the bag from a frozen state

The lock taken result from the Freeze method

local helper method to acquire all local lists locks

Local helper method to release all local lists locks

Local helper function to wait all unsynchronized operations

Local helper function to get the bag count, the caller should call it from Freeze/Unfreeze block

The current bag count

Local helper function to return the bag item in a list, this is mainly used by CopyTo and ToArray This is not thread safe, should be called in Freeze/UnFreeze bag block

List the contains the bag items

Gets the number of elements contained in the .

The number of elements contained in the . The count returned represents a moment-in-time snapshot of the contents of the bag. It does not reflect any updates to the collection after was called.

Gets a value that indicates whether the is empty.

true if the is empty; otherwise, false.

Gets a value indicating whether access to the is synchronized with the SyncRoot.

true if access to the is synchronized with the SyncRoot; otherwise, false. For , this property always returns false.

Gets an object that can be used to synchronize access to the . This property is not supported.

The SyncRoot property is not supported.

A class that represents a node in the lock thread list

A class that represents the lock thread list

ThreadLocalList constructor

The owner thread for this list

Add new item to head of the list

The item to add. Whether to update the count.

Remove an item from the head of the list

The removed item

Peek an item from the head of the list

the peeked item True if succeeded, false otherwise

Steal an item from the tail of the list

the removed item remove or peek flag

Gets the total list count, it's not thread safe, may provide incorrect count if it is called concurrently

List operations

A simple class for the debugger view window

Provides a set of methods for querying objects that implement ParallelQuery{TSource}. This is the parallel equivalent of .

Enables parallelization of a query.

The type of elements of . An to convert to a . The source as a to bind to ParallelEnumerable extension methods. is a null reference (Nothing in Visual Basic).

Enables parallelization of a query, as sourced by a partitioner responsible for splitting the input sequence into partitions.

The type of elements of . A partitioner over the input sequence. The as a ParallelQuery to bind to ParallelEnumerable extension methods. The source partitioner's GetOrderedPartitions method is used when ordering is enabled, whereas the partitioner's GetPartitions is used if ordering is not enabled (the default). The source partitioner's GetDynamicPartitions and GetDynamicOrderedPartitions are not used. is a null reference (Nothing in Visual Basic).

Enables treatment of a data source as if it was ordered, overriding the default of unordered. AsOrdered may only be invoked on sequences returned by AsParallel, ParallelEnumerable.Range, and ParallelEnumerable.Repeat.

The type of elements of . The input sequence. Thrown if is not one of AsParallel, ParallelEnumerable.Range, or ParallelEnumerable.Repeat. is a null reference (Nothing in Visual Basic). A natural tension exists between performance and preserving order in parallel processing. By default, a parallelized query behaves as if the ordering of the results is arbitrary unless AsOrdered is applied or there is an explicit OrderBy operator in the query. The source sequence which will maintain ordering in the query.

The input sequence. Thrown if the is not one of AsParallel, ParallelEnumerable.Range, or ParallelEnumerable.Repeat. is a null reference (Nothing in Visual Basic). A natural tension exists between performance and preserving order in parallel processing. By default, a parallelized query behaves as if the ordering of the results is arbitrary unless AsOrdered is applied or there is an explicit OrderBy operator in the query. The source sequence which will maintain ordering in the query.

Allows an intermediate query to be treated as if no ordering is implied among the elements.

AsUnordered may provide performance benefits when ordering is not required in a portion of a query. The type of elements of . The input sequence. The source sequence with arbitrary order. is a null reference (Nothing in Visual Basic).

Enables parallelization of a query.

An to convert to a . The source as a ParallelQuery to bind to ParallelEnumerable extension methods. is a null reference (Nothing in Visual Basic).

Converts a into an to force sequential evaluation of the query.

The type of elements of . A to convert to an . The source as an to bind to sequential extension methods. is a null reference (Nothing in Visual Basic).

Sets the task scheduler to execute the query.

The type of elements of . A ParallelQuery on which to set the task scheduler option. Task scheduler to execute the query. ParallelQuery representing the same query as source, but with the task scheduler option set. or is a null reference (Nothing in Visual Basic). WithTaskScheduler is used multiple times in the query.

Sets the degree of parallelism to use in a query. Degree of parallelism is the maximum number of concurrently executing tasks that will be used to process the query.

The type of elements of . A ParallelQuery on which to set the limit on the degrees of parallelism. The degree of parallelism for the query. ParallelQuery representing the same query as source, with the limit on the degrees of parallelism set. is a null reference (Nothing in Visual Basic). WithDegreeOfParallelism is used multiple times in the query. is less than 1 or greater than 63.

Sets the to associate with the query.

The type of elements of . A ParallelQuery on which to set the option. A cancellation token. ParallelQuery representing the same query as source, but with the registered. is a null reference (Nothing in Visual Basic). WithCancellation is used multiple times in the query. The associated with the has been disposed.

Sets the execution mode of the query.

The type of elements of . A ParallelQuery on which to set the option. The mode in which to execute the query. ParallelQuery representing the same query as source, but with the registered. is a null reference (Nothing in Visual Basic). is not a valid value. WithExecutionMode is used multiple times in the query.

Sets the merge options for this query, which specify how the query will buffer output.

The type of elements of . A ParallelQuery on which to set the option. The merge optiosn to set for this query. ParallelQuery representing the same query as source, but with the registered. is a null reference (Nothing in Visual Basic). is not a valid value. WithMergeOptions is used multiple times in the query.

Generates a parallel sequence of integral numbers within a specified range.

The value of the first integer in the sequence. The number of sequential integers to generate. An IEnumerable<Int32> in C# or IEnumerable(Of Int32) in Visual Basic that contains a range of sequential integral numbers. is less than 0 -or- + - 1 is larger than .

Generates a parallel sequence that contains one repeated value.

The type of the value to be repeated in the result sequence. The value to be repeated. The number of times to repeat the value in the generated sequence. A sequence that contains a repeated value. is less than 0.

Returns an empty ParallelQuery{TResult} that has the specified type argument.

The type to assign to the type parameter of the returned generic sequence. An empty sequence whose type argument is .

Invokes in parallel the specified action for each element in the .

This is an efficient way to process the output from a parallelized query because it does not require a merge step at the end. However, order of execution is non-deterministic. The type of elements of . The whose elements will be processed by . An Action to invoke on each element. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Filters in parallel a sequence of values based on a predicate.

The type of the elements of source. A sequence to filter. A function to test each element for a condition. A sequence that contains elements from the input sequence that satisfy the condition. or is a null reference (Nothing in Visual Basic).

Filters in parallel a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.

Projects in parallel each element of a sequence into a new form.

The type of the elements of . The type of elements resturned by selector. A sequence of values to invoke a transform function on. A transform function to apply to each element. A sequence whose elements are the result of invoking the transform function on each element of . or is a null reference (Nothing in Visual Basic).

Projects in parallel each element of a sequence into a new form by incorporating the element's index.

Merges in parallel two sequences by using the specified predicate function.

The type of the elements of the first sequence. The type of the elements of the second sequence. The type of the return elements. The first sequence to zip. The second sequence to zip. A function to create a result element from two matching elements. A sequence that has elements of type that are obtained by performing resultSelector pairwise on two sequences. If the sequence lengths are unequal, this truncates to the length of the shorter sequence. or or is a null reference (Nothing in Visual Basic).

This Zip overload should never be called. This method is marked as obsolete and always throws when invoked.

This type parameter is not used. This type parameter is not used. This type parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This overload always throws a . The exception that occurs when this method is called. This overload exists to disallow usage of Zip with a left data source of type and a right data source of type . Otherwise, the Zip operator would appear to be bind to the parallel implementation, but would in reality bind to the sequential implementation.

Correlates in parallel the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.

The type of the elements of the first sequence. The type of the elements of the second sequence. The type of the keys returned by the key selector functions. The type of the result elements. The first sequence to join. The sequence to join to the first sequence. A function to extract the join key from each element of the first sequence. A function to extract the join key from each element of the second sequence. A function to create a result element from two matching elements. A sequence that has elements of type that are obtained by performing an inner join on two sequences. or or or or is a null reference (Nothing in Visual Basic).

This Join overload should never be called. This method is marked as obsolete and always throws when invoked.

This type parameter is not used. This type parameter is not used. This type parameter is not used. This type parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This overload always throws a . The exception that occurs when this method is called. This overload exists to disallow usage Join with a left data source of type and a right data source of type . Otherwise, the Join operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation.

Correlates in parallel the elements of two sequences based on matching keys. A specified IEqualityComparer{T} is used to compare keys.

The type of the elements of the first sequence. The type of the elements of the second sequence. The type of the keys returned by the key selector functions. The type of the result elements. The first sequence to join. The sequence to join to the first sequence. A function to extract the join key from each element of the first sequence. A function to extract the join key from each element of the second sequence. A function to create a result element from two matching elements. An IEqualityComparer<(Of <(T>)>) to hash and compare keys. A sequence that has elements of type that are obtained by performing an inner join on two sequences. or or or or is a null reference (Nothing in Visual Basic).

This Join overload should never be called. This method is marked as obsolete and always throws when invoked.

This type parameter is not used. This type parameter is not used. This type parameter is not used. This type parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This overload always throws a . The exception that occurs when this method is called. This overload exists to disallow usage of Join with a left data source of type and a right data source of type . Otherwise, the Join operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation.

Correlates in parallel the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.

The type of the elements of the first sequence. The type of the elements of the second sequence. The type of the keys returned by the key selector functions. The type of the result elements. The first sequence to join. The sequence to join to the first sequence. A function to extract the join key from each element of the first sequence. A function to extract the join key from each element of the second sequence. A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. A sequence that has elements of type that are obtained by performing a grouped join on two sequences. or or or or is a null reference (Nothing in Visual Basic).

This GroupJoin overload should never be called. This method is marked as obsolete and always throws when called.

This type parameter is not used. This type parameter is not used. This type parameter is not used. This type parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This overload always throws a . The exception that occurs when this method is called. This overload exists to disallow usage of GroupJoin with a left data source of type and a right data source of type . Otherwise, the GroupJoin operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation.

Correlates in parallel the elements of two sequences based on key equality and groups the results. A specified IEqualityComparer{T} is used to compare keys.

The type of the elements of the first sequence. The type of the elements of the second sequence. The type of the keys returned by the key selector functions. The type of the result elements. The first sequence to join. The sequence to join to the first sequence. A function to extract the join key from each element of the first sequence. A function to extract the join key from each element of the second sequence. A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. An IEqualityComparer<(Of <(T>)>) to hash and compare keys. A sequence that has elements of type that are obtained by performing a grouped join on two sequences. or or or or is a null reference (Nothing in Visual Basic).

This GroupJoin overload should never be called. This method is marked as obsolete and always throws when called.

This type parameter is not used. This type parameter is not used. This type parameter is not used. This type parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This parameter is not used. This overload always throws a . The exception that occurs when this method is called. This overload exists to disallow usage of GroupJoin with a left data source of type and a right data source of type . Otherwise, the GroupJoin operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation.

Projects in parallel each element of a sequence to an IEnumerable{T} and flattens the resulting sequences into one sequence.

The type of elements of . The type of the elements of the sequence returned by selector. A sequence of values to project. A transform function to apply to each element. A sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. or is a null reference (Nothing in Visual Basic).

Projects in parallel each element of a sequence to an IEnumerable{T}, and flattens the resulting sequences into one sequence. The index of each source element is used in the projected form of that element.

Projects each element of a sequence to an IEnumerable{T}, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

The type of elements of . The type of the intermediate elements collected by . A sequence of values to project. A transform function to apply to each source element; the second parameter of the function represents the index of the source element. A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. A sequence whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. or or is a null reference (Nothing in Visual Basic).

Projects each element of a sequence to an IEnumerable{T}, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element.

The type of elements of . The type of the intermediate elements collected by . The type of elements to return. A sequence of values to project. A transform function to apply to each source element; the second parameter of the function represents the index of the source element. A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. A sequence whose elements are the result of invoking the one-to-many transform function on each element of and then mapping each of those sequence elements and their corresponding source element to a result element. or or is a null reference (Nothing in Visual Basic).

Sorts in parallel the elements of a sequence in ascending order according to a key.

In contrast to the sequential implementation, this is not a stable sort. To achieve a stable sort, change a query of the form: var ordered = source.OrderBy((e) => e.k); to instead be formed as: var ordered = source.Select((e,i) => new { E=e, I=i }).OrderBy((v) => v.i).Select((v) => v.e); The type of elements of . The type of the key returned by . A sequence of values to order. A function to extract a key from an element. An OrderedParallelQuery{TSource} whose elements are sorted according to a key. or is a null reference (Nothing in Visual Basic).

Sorts in parallel the elements of a sequence in ascending order by using a specified comparer.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . A sequence of values to order. A function to extract a key from an element. An IComparer{TKey} to compare keys. An OrderedParallelQuery{TSource} whose elements are sorted according to a key. or is a null reference (Nothing in Visual Basic).

Sorts in parallel the elements of a sequence in descending order according to a key.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . A sequence of values to order. A function to extract a key from an element. An OrderedParallelQuery{TSource} whose elements are sorted descending according to a key. or is a null reference (Nothing in Visual Basic).

Sorts the elements of a sequence in descending order by using a specified comparer.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . A sequence of values to order. A function to extract a key from an element. An IComparer{TKey} to compare keys. An OrderedParallelQuery{TSource} whose elements are sorted descending according to a key. or is a null reference (Nothing in Visual Basic).

Performs in parallel a subsequent ordering of the elements in a sequence in ascending order according to a key.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . An OrderedParallelQuery{TSource} than contains elements to sort. A function to extract a key from an element. An OrderedParallelQuery{TSource} whose elements are sorted according to a key. or is a null reference (Nothing in Visual Basic).

Performs in parallel a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . An OrderedParallelQuery{TSource} that contains elements to sort. A function to extract a key from an element. An IComparer{TKey} to compare keys. An OrderedParallelQuery{TSource} whose elements are sorted according to a key. or is a null reference (Nothing in Visual Basic).

Performs in parallel a subsequent ordering of the elements in a sequence in descending order, according to a key.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . An OrderedParallelQuery{TSource} than contains elements to sort. A function to extract a key from an element. An OrderedParallelQuery{TSource} whose elements are sorted descending according to a key. or is a null reference (Nothing in Visual Basic).

Performs in parallel a subsequent ordering of the elements in a sequence in descending order by using a specified comparer.

In contrast to the sequential implementation, this is not a stable sort. See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for an approach to implementing a stable sort. The type of elements of . The type of the key returned by . An OrderedParallelQuery{TSource} than contains elements to sort. A function to extract a key from an element. An IComparer{TKey} to compare keys. An OrderedParallelQuery{TSource} whose elements are sorted descending according to a key. or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a specified key selector function.

The type of elements of . The type of the key returned by . An OrderedParallelQuery{TSource}than contains elements to sort. A function to extract a key from an element. An OrderedParallelQuery{TSource}whose elements are sorted descending according to a key.

Groups in parallel the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

The type of elements of . The type of the key returned by >. An OrderedParallelQuery{TSource} than contains elements to sort. A function to extract a key from an element. An IComparer{TSource} to compare keys. An OrderedParallelQuery{TSource} whose elements are sorted descending according to a key. or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

The type of elements of . The type of the key returned by . The type of the elements in the IGrouping An OrderedParallelQuery<(Of <(TElement>)>) than contains elements to sort. A function to extract a key from an element. A function to map each source element to an element in an IGrouping. A ParallelQuery<IGrouping<TKey, TElement>> in C# or ParallelQuery(Of IGrouping(Of TKey, TElement)) in Visual Basic where each IGrouping generic object contains a collection of objects of type and a key. or or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.

The type of elements of . The type of the key returned by . The type of the elements in the IGrouping An OrderedParallelQuery{TSource}than contains elements to sort. A function to extract a key from an element. A function to map each source element to an element in an IGrouping. An IComparer{TSource} to compare keys. A ParallelQuery{IGrouping{TKey, TElement}} in C# or ParallelQuery(Of IGrouping(Of TKey, TElement)) in Visual Basic where each IGrouping generic object contains a collection of objects of type and a key. or or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

The type of the elements of . The type of the key returned by . The type of the result value returned by . A sequence whose elements to group. A function to extract the key for each element. A function to create a result value from each group. A collection of elements of type where each element represents a projection over a group and its key. or or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer.

The type of the elements of . The type of the key returned by . The type of the result value returned by . A sequence whose elements to group. A function to extract the key for each element. A function to create a result value from each group. An IEqualityComparer{TKey} to compare keys. An ParallelQuery<IGrouping<TKey, TResult>> in C# or ParallelQuery(Of IGrouping(Of TKey, TResult)) in Visual Basic where each IGrouping<(Of <(TKey, TResult>)>) object contains a collection of objects of type and a key. or or is a null reference (Nothing in Visual Basic).

Groups in parallel the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.

The type of the elements of . The type of the key returned by . The type of the elements in each IGrouping{TKey, TElement}. The type of the result value returned by . A sequence whose elements to group. A function to extract the key for each element. A function to map each source element to an element in an IGrouping<TKey, TElement>. A function to create a result value from each group. A collection of elements of type where each element represents a projection over a group and its key. or or or is a null reference (Nothing in Visual Basic).

Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

The type of the elements of . The type of the key returned by . The type of the elements in each IGrouping{TKey, TElement}. The type of the result value returned by . A sequence whose elements to group. A function to extract the key for each element. A function to map each source element to an element in an IGrouping{Key, TElement}. A function to create a result value from each group. An IEqualityComparer{TKey} to compare keys. A collection of elements of type where each element represents a projection over a group and its key. or or or is a null reference (Nothing in Visual Basic).

Run an aggregation sequentially. If the user-provided reduction function throws an exception, wrap it with an AggregateException.

if true, use the seed provided in the method argument if false, use the first element of the sequence as the seed instead

Applies in parallel an accumulator function over a sequence.

The type of the elements of . A sequence to aggregate over. An accumulator function to be invoked on each element. The final accumulator value. or is a null reference (Nothing in Visual Basic). contains no elements. One or more exceptions occurred during the evaluation of the query. The query was canceled.

Applies in parallel an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

The type of the elements of . The type of the accumulator value. A sequence to aggregate over. The initial accumulator value. An accumulator function to be invoked on each element. The final accumulator value. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Applies in parallel an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

The type of the elements of . The type of the accumulator value. The type of the resulting value. A sequence to aggregate over. The initial accumulator value. An accumulator function to be invoked on each element. A function to transform the final accumulator value into the result value. The transformed final accumulator value. or or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Applies in parallel an accumulator function over a sequence. This overload is not available in the sequential implementation.

This overload is specific to processing a parallelized query. A parallelized query may partition the data source sequence into several sub-sequences (partitions). The is invoked on each element within partitions. Each partition then yields a single accumulated result. The is then invoked on the results of each partition to yield a single element. This element is then transformed by the function. The type of the elements of . The type of the accumulator value. The type of the resulting value. A sequence to aggregate over. The initial accumulator value. An accumulator function to be invoked on each element in a partition. An accumulator function to be invoked on the yielded element from each partition. A function to transform the final accumulator value into the result value. The transformed final accumulator value. or or or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Applies in parallel an accumulator function over a sequence. This overload is not available in the sequential implementation.

This overload is specific to parallelized queries. A parallelized query may partition the data source sequence into several sub-sequences (partitions). The is invoked on each element within partitions. Each partition then yields a single accumulated result. The is then invoked on the results of each partition to yield a single element. This element is then transformed by the function. The type of the elements of . The type of the accumulator value. The type of the resulting value. A sequence to aggregate over. A function that returns the initial accumulator value. An accumulator function to be invoked on each element in a partition. An accumulator function to be invoked on the yielded element from each partition. A function to transform the final accumulator value into the result value. The transformed final accumulator value. or or or or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Returns the number of elements in a parallel sequence.

The type of the elements of . A sequence that contains elements to be counted. The number of elements in the input sequence. is a null reference (Nothing in Visual Basic). The number of elements in source is larger than . -or- One or more exceptions occurred during the evaluation of the query. The query was canceled.

Returns a number that represents how many elements in the specified parallel sequence satisfy a condition.

The type of the elements of . A sequence that contains elements to be counted. A function to test each element for a condition. A number that represents how many elements in the sequence satisfy the condition in the predicate function. or is a null reference (Nothing in Visual Basic). The number of elements in source is larger than . -or- One or more exceptions occurred during the evaluation of the query. The query was canceled.

Returns an Int64 that represents the total number of elements in a parallel sequence.

Returns an Int64 that represents how many elements in a parallel sequence satisfy a condition.

Computes in parallel the sum of a sequence of values.

A sequence of values to calculate the sum of. The sum of the values in the sequence. is a null reference (Nothing in Visual Basic). The sum is larger than . -or- One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of a sequence of values.

A sequence of values to calculate the sum of. The sum of the values in the sequence. is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of a sequence of values.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). The sum is larger than . -or- One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

The type of elements of . A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). The sum is larger than . -or- One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

The type of elements of . A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

The type of elements of . A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

The type of elements of . A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

The type of elements of . A sequence of values to calculate the sum of. A transform function to apply to each element. The sum of the values in the sequence. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Computes in parallel the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.

Returns the minimum value in a parallel sequence of values.

A sequence of values to determine the minimum value of. The minimum value in the sequence. is a null reference (Nothing in Visual Basic). contains no elements. One or more exceptions occurred during the evaluation of the query. The query was canceled.

Returns the minimum value in a parallel sequence of values.

A sequence of values to determine the minimum value of. The minimum value in the sequence. is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.

Returns the minimum value in a parallel sequence of values.

The type of elements of . A sequence of values to determine the minimum value of. The minimum value in the sequence. is a null reference (Nothing in Visual Basic). contains no elements and is a non-nullable value type. One or more exceptions occurred during the evaluation of the query. The query was canceled.

Invokes in parallel a transform function on each element of a sequence and returns the minimum value.

The type of elements of . A sequence of values to determine the minimum value of. A transform function to apply to each element. The minimum value in the sequence. or is a null reference (Nothing in Visual Basic). contains no elements. One or more exceptions occurred during the evaluation of the query. The query was canceled.

Invokes in parallel a transform function on each element of a sequence and returns the minimum value.

The type of elements of . A sequence of values to determine the minimum value of. A transform function to apply to each element. The minimum value in the sequence. or is a null reference (Nothing in Visual Basic). One or more exceptions occurred during the evaluation of the query. The query was canceled.