Gemstone.Threading

Represents a lock that can be awaited to obtain exclusive access to resources within a critical region of code.

Attempts to obtain exclusive access to the lock.

A task that, if cancelled, indicates the lock was not taken, and must be awaited to obtain the token that will release the lock on . The lock could not be taken.

Attempts to obtain exclusive access to the lock.

The number of milliseconds to wait before failing to take the lock. A task that, if cancelled, indicates the lock was not taken, and must be awaited to obtain the token that will release the lock on . The timeout expires before the lock could be taken.

Attempts to obtain exclusive access to the lock.

The amount of time to wait before failing to take the lock. A task that, if cancelled, indicates the lock was not taken, and must be awaited to obtain the token that will release the lock on . The expires before the lock could be taken. The following illustrates an example of using try-catch to detect a failure to take the lock. AsyncLock asyncLock = new AsyncLock(); try { using IDisposable token = await asyncLock.TryEnterAsync(); // Critical region } catch (TaskCanceledException) { // Lock failed } The following illustrates an example of using to detect a failure to take the lock. AsyncLock asyncLock = new AsyncLock(); await asyncLock.TryEnterAsync().ContinueWith(async tokenTask => { if (tokenTask.IsCanceled) { // Lock failed return; } using IDisposable token = await tokenTask; // Critical region }).Unwrap();

Obtains exclusive access to the lock.

A task that must be awaited to obtain the token that will release the lock on .

Represents an asynchronous implementation of a reader/writer lock.

Attempts to enter the lock with concurrent access where all readers can execute concurrently with respect to each other.

The number of milliseconds to wait before timing out. The token used to control the duration of entry. The lock could not be entered before the timeout expired.

Attempts to enter the lock with concurrent access where all readers can execute concurrently with respect to each other.

The amount of time to wait before timing out. The token used to control the duration of entry. The lock could not be entered before the expired.

Attempts to enter the lock with exclusive access where no other readers or writers can execute concurrently with the writer.

The number of milliseconds to wait before timing out. The token used to control the duration of entry. The lock could not be entered before the timeout expired.

Attempts to enter the lock with exclusive access where no other readers or writers can execute concurrently with the writer.

The amount of time to wait before timing out. The token used to control the duration of entry. The lock could not be entered before the expired.

Enters the lock with concurrent access where all readers can execute concurrently with respect to each other.

The token used to control the duration of entry.

Enters the lock with exclusive access where no other readers or writers can execute concurrently with the writer.

The token used to control the duration of entry.

Combines and to provide a low-contention, double-buffered queue suitable for multiple-producer, single-consumer scenarios.

Type of items being queued.

Event that is raised if an exception is encountered while attempting to processing an item in the .

Processing will not stop for any exceptions thrown by user processing function, but exceptions will be exposed through this event.

Creates a new instance of the class.

Gets or sets item processing function.

Gets the number of items in the queue.

Enqueues a collection of items into the async double-buffered queue.

The items to be queued.

Creates a fast, light-weight asynchronous processing queue with very low contention.

Type of items to process.

Event that is raised if an exception is encountered while attempting to processing an item in the .

Processing will not stop for any exceptions thrown by user processing function, but exceptions will be exposed through this event.

Creates a new .

Creates a new .

The type of synchronized operation to use to process items in the queue.

Gets the total number of items currently in the queue.

Gets or sets item processing function.

Gets or sets flag that enables or disables processing.

Enqueues an item for processing.

Item to be queued for processing.

A thread-safe double-buffered queue that allows for low-contention item processing in single-producer, single-consumer scenarios.

Type of items being queued. It is not safe to use this class with multiple consumer threads. The method must be called by one thread at a time, and the consumer must not access a list returned by Dequeue after its next call to Dequeue.

Event that is raised if an exception is encountered while attempting to processing an item in the .

Processing will not stop for any exceptions thrown by user processing function, but exceptions will be exposed through this event.

Creates a new instance of the class.

Gets or sets item processing function.

Gets the current number of items in the queue.

Enqueues a collection of items into the double-buffered queue.

The collection of items to be enqueued.

Dequeues a collection of items from the queue.

A collection of items that have previously been enqueued, or no items if none have been enqueued since last dequeue.

Empties the producer's buffer so that the items can no longer be consumed by the consumer.

Attempts to enqueue a collection of items into the double-buffered queue.

The collection of items to be enqueued. True if the items were successfully enqueued; false otherwise.

Attempts to dequeue a collection of items from the queue and returns the number of items left in the queue after dequeuing.

The items that were dequeued. The number of items left in the queue after dequeuing as many items as possible.

Attempts to enqueue a collection of items into the double-buffered queue.

True if the items were successfully enqueued; false otherwise.

A producer for a which can only be used to provide items to the queue for consumption.

The type of the items produced to the queue.

Creates a new instance of the class.

The that created this producer. The that this producer will be producing to.

Releases the unmanaged resources before the object is reclaimed by .

Produces a collection of items to be processed by the consumer.

The collection of items to be enqueued.

Releases all the resources used by the object.

Releases the unmanaged resources used by the object and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Manages queues to reduce contention for a multithreaded, multiple-producer, single-consumer scenario.

For best results, each thread that is producing items to the consumer should call to receive a producer object that will not contend with any other producer. The consumer should either provide a handler to process the queued items or poll the manager by calling (not both!). It is not safe to use this class with multiple consumer threads. The types of items to be queued. It is not safe to use this class with multiple consumer threads. The list returned by is not thread-safe and is reused on each Dequeue operation, so no other thread should access the list while another thread is calling Dequeue.

Creates a new instance of the class.

Creates a new instance of the class.

The method to handle processing of queued items.

Creates a new instance of the class.

The method to handle processing of queued items.

Creates a new instance of the class.

The method to handle processing of queued items. The method to handle exceptions that occur when processing items.

Creates a new instance of the class.

The method to handle processing of queued items. The method to handle exceptions that occur when processing items.

Gets a flag that indicates whether there are any items left to be consumed after the last call to .

Creates a producer used to produce items to the consumer of this .

A used to produce items to the consumer.

Dequeues a list of items produced by the s.

A list of items to be consumed.

Runs the operation to process items produced by the s.

Returns a queue to the so that it can be removed from the list of queues to be consumed.

The queue to be returned.

The namespace provides classes for collections related to threading functionality, e.g., .

Represents a thread-safe prioritized first in-first out (FIFO) collection.

The type of elements contained in the queue.

Creates a new instance of the class.

Creates a new instance of the class.

The number of priority levels to preallocate in the queue. is less than or equal to 0.

Creates a new instance of the class.

Another priority queue of items to be enqueued in this queue at the same priority. queue length is less than or equal to 0. is null.

Gets the number of items in the queue.

Indicates whether the is empty.

Enqueues an item into the priority queue.

The item to be enqueued. The priority at which the item should be queued. Larger numbers have higher priority! is negative This priority queue is implemented using an array of . The array index indicates the priority of tasks in each queue. For best performance, ensure that your code defines all priority levels consecutively, starting from 0.

Dequeues an item from the priority queue.

The priority at which the item should be dequeued. The item that was dequeued, or the default value if no item was dequeued. True if an item was dequeued; false if the queue is empty.

Dequeues an item from the priority queue.

The item that was dequeued, or the default value if no item was dequeued. True if an item was dequeued; false if the queue is empty.

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

The priority at which to peek into the queue. When this method returns, result contains an object from the beginning of the or an unspecified value if the operation failed. true if an object was returned successfully; otherwise, false.

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

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

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 array at which copying begins. array is a null reference (Nothing in Visual Basic). index is less than zero. index is equal to or greater than the length of the array -or- The number of elements in the source is greater than the available space from index to the end of the destination array.

Returns an enumerator that iterates through the .

An enumerator for the contents of the .

Copies the elements stored in the to a new array.

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

Enumeration of possible threading modes.

Processes several items in the at once on different threads, where processing order is not important.

Processes items in the one at a time on a single thread, where processing order is important.

Enumeration of possible processing styles.

Defines processing delegate to process only one item at a time.

This is the typical when the is asynchronous.

Defines processing delegate to process all currently available items in the . Items are passed into delegate as an array.

This is the optimal when the is synchronous.

Enumeration of possible requeue reasons.

Requeuing item since it cannot be processed at this time.

Requeuing item due to an exception.

Requeuing item due to timeout.

Enumeration of possible requeue modes.

Requeues item at the beginning of the .

Requeues item at the end of the .

Represents a thread-safe (via locking) list of items, based on , that get processed on independent threads with a consumer provided function.

Type of object to process This class acts as a strongly-typed collection of objects to be processed. Note that the will not start processing until the Start method is called.

Default processing interval (in milliseconds).

Default maximum number of processing threads.

Default processing timeout (in milliseconds).

Default setting for requeuing items on processing timeout.

Default setting for requeuing items on processing exceptions.

Default real-time processing interval (in milliseconds).

Default setting for requeuing mode on processing timeout.

Default setting for requeuing mode on processing exceptions.

Function signature that defines a method to process items one at a time.

Item to be processed. Required unless is implemented. Creates an asynchronous to process individual items - one item at a time - on multiple threads.

Function signature that defines a method to process multiple items at once.

Items to be processed. Required unless is implemented. Creates an asynchronous to process groups of items simultaneously on multiple threads.

Function signature that determines if an item can be currently processed.

Item to be checked for processing availability. True, if item can be processed. The default is true. Implementation of this function is optional. It is assumed that an item can be processed if this function is not defined Items must eventually get to a state where they can be processed, or they will remain in the indefinitely. Note that when this function is implemented and ProcessingStyle = ManyAtOnce (i.e., is defined), then each item presented for processing must evaluate as "CanProcessItem = True" before any items are processed.

Event that is raised after an item has been successfully processed.

Allows custom handling of successfully processed items. Allows notification when an item has completed processing in the allowed amount of time, if a process timeout is specified. Raised only when ProcessingStyle = OneAtATime (i.e., is defined).

Event that is raised after an array of items have been successfully processed.

Allows custom handling of successfully processed items. Allows notification when an item has completed processing in the allowed amount of time, if a process timeout is specified. Raised only when when ProcessingStyle = ManyAtOnce (i.e., is defined).

Event that is raised if an item's processing time exceeds the specified process timeout.

Allows custom handling of items that took too long to process. Raised only when ProcessingStyle = OneAtATime (i.e., is defined).

Event that is raised if the processing time for an array of items exceeds the specified process timeout.

Allows custom handling of items that took too long to process. Raised only when ProcessingStyle = ManyAtOnce (i.e., is defined).

Event that is raised if an exception is encountered while attempting to processing an item in the .

Processing will not stop for any exceptions thrown by the user function, but any captured exceptions will be exposed through this event.

Occurs when the class has been disposed.

Creates a based on the generic List(Of T) class.

Delegate that defines a method to process one item at a time. a value which represents the process interval in milliseconds. The maximum number of threads for the queue to use. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception.

Creates a based on the generic List(Of T) class.

Delegate that defines a method to process one item at a time. Delegate that determines if an item can currently be processed. a value which represents the process interval in milliseconds. The maximum number of threads for the queue to use. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception.

Creates a bulk item based on the generic List(Of T) class.

Delegate that defines a method to process multiple items at once. a value which represents the process interval in milliseconds. The maximum number of threads for the queue to use. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception.

Creates a bulk item based on the generic List(Of T) class.

Delegate that defines a method to process multiple items at once. Delegate that determines if an item can currently be processed. a value which represents the process interval in milliseconds. The maximum number of threads for the queue to use. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception.

Allows derived classes to define their own instance, if desired.

Delegate that defines a method to process one item at a time. Delegate that defines a method to process multiple items at once. Delegate that determines if an item can currently be processed. A storage list for items to be processed. a value which represents the process interval in milliseconds. The maximum number of threads for the queue to use. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception.

Releases the unmanaged resources before the object is reclaimed by .

Gets or sets the element at the specified index.

The element at the specified index. The zero-based index of the element to get or set. index is less than 0 -or- index is equal to or greater than length.

Attempts to remove and return an object from the .

When this method returns, if the object was removed and returned successfully, item 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.

Attempts to remove and return all objects from the .

When this method returns, if any objects were removed and returned successfully, item array contains the removed objects. If no object was available to be removed, the value is null. true if any objects were removed and returned successfully; otherwise, false.

Gets a value indicating whether the is read-only.

True, if the is read-only; otherwise, false. In the default implementation, this property always returns false.

Gets or sets the user function for processing individual items in the one at a time.

Cannot be defined simultaneously with . A must be defined to process a single item at a time or many items at once. Implementation makes ProcessingStyle = OneAtATime.

Gets or sets the user function for processing multiple items in the at once.

This function and cannot be defined at the same time A must be defined to process a single item at a time or many items at once Implementation of this function makes ProcessingStyle = ManyAtOnce

Gets or sets the user function determining if an item is ready to be processed.

Gets indicator that items will be processed in real-time.

Gets the current for the (i.e., synchronous or asynchronous).

The maximum number of processing threads determines the . If the maximum threads are set to one, item processing will be synchronous (i.e., ThreadingMode = Synchronous). If the maximum threads are more than one, item processing will be asynchronous (i.e., ThreadingMode = Asynchronous). Note that for asynchronous , the processing interval will control how many threads are spawned at once. If items are processed faster than the specified processing interval, only one process thread will ever be spawned at a time. To ensure multiple threads are utilized to items, lower the process interval (minimum process interval is 1 millisecond).

Gets the item for the (i.e., one at a time or many at once).

OneAtATime, if the is implemented. ManyAtOnce, if the is implemented. The implemented item processing function determines the . If the is ManyAtOnce, all available items in the are presented for processing at each processing interval. If you expect items to be processed in the order in which they were received, make sure you use a synchronous . Real-time are inherently synchronous.

Gets or sets the interval, in milliseconds, on which new items begin processing.

Gets or sets the maximum number of threads to process simultaneously.

Sets the maximum number of processing threads. Maximum number of processing threads. If MaximumThreads is set to one, item processing will be synchronous (i.e., ThreadingMode = Synchronous)

Gets or sets the maximum time, in milliseconds, allowed for processing an item.

Sets the maximum number of milliseconds allowed to process an item. The maximum number of milliseconds allowed to process an item. Set to Timeout.Infinite (i.e., -1) to allow processing to take as long as needed.

Gets or sets the type of synchronized operation used to process items in a real-time .

Gets or sets whether or not to automatically place an item back into the if the processing times out.

Ignored if the ProcessTimeout is set to Timeout.Infinite (i.e., -1).

Gets or sets whether or not to automatically place an item back into the if an exception occurs while processing.

Gets or sets the mode of insertion used (prefix or suffix) when at item is placed back into the after processing times out.

Only relevant when RequeueOnTimeout = True.

Gets or sets the mode of insertion used (prefix or suffix) when at item is placed back into the after an exception occurs while processing.

Only relevant when RequeueOnException = True.

Gets or sets indicator that the is currently enabled.

Gets a flag that indicates whether the object has been disposed.

Gets indicator that the is actively processing items.

Gets a value that indicates whether the is empty.

Gets the total number of items currently being processed.

Gets the total number of items processed so far.

Gets the total number of calls to or .

Gets the current number of active threads.

Current number of active threads.

Gets the total amount of time, in seconds, that the has been active.

Gets or sets name for this .

This name is used for class identification in strings (e.g., used in error messages).

Gets the number of elements actually contained in the .

The number of elements actually contained in the .

Gets a value indicating whether access to the is synchronized (thread safe). Always returns true for .

true, is always synchronized (thread safe). The is effectively "synchronized" since all functions SyncLock operations internally.

Gets the per processing thread cancellation token to check when a is specified.

This token should be checked in the user implemented or to determine if a timeout has occurred so that the code can cleanly exit.

Gets the current run-time statistics of the as a single group of values.

Gets current status of .

Allows derived classes to access the interfaced internal directly.

Gets an object that can be used to synchronize access to the .

Gets the internal list for direct use by .

Releases all the resources used by the object.

Releases the unmanaged resources used by the object and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Manually signals that data has been modified and processing should resume.

This function should be called in cases where a user may need to signal data modification. For example, if was a dictionary or list that was updated - you would need to manually signal that data had changed in this item.

Determines whether an element is in the .

True, if item is found in the ; otherwise, false. The object to locate in the . The value can be null for reference types.

Copies the elements contained in the to a new array.

A new array containing the elements copied from the .

Returns an enumerator that iterates through the .

An enumerator for the .

Starts item processing.

Stops item processing.

Blocks the current thread, if the is active (i.e., user has called "Start" method), until all items in are processed, and then stops the .

Begins processing items as quickly as possible, regardless of currently defined process interval, until all items in the have been processed. Stops the when this function ends. This method is typically called on shutdown to make sure any remaining queued items get processed before the is destructed. It is possible for items to be added to the while the flush is executing. The flush will continue to process items as quickly as possible until the is empty. Unless the user stops queuing items to be processed, the flush call may never return (not a happy situation on shutdown). For this reason, during this function call, requeuing of items on exception or process timeout is temporarily disabled. The does not clear queue prior to destruction. If the user fails to call this method before the class is destructed, there may be items that remain unprocessed in the .

Raises the base class event.

Derived classes cannot raise events of their base classes, so we expose event wrapper methods to accommodate as needed. A generic type T to be passed to ItemProcessed.

Raises the base class event.

Derived classes cannot raise events of their base classes, so we expose event wrapper methods to accommodate as needed. An array of generic type T to be passed to ItemsProcessed.

Raises the base class event.

Derived classes cannot raise events of their base classes, so we expose event wrapper methods to accommodate as needed. A generic type T to be passed to ItemProcessed.

Raises the base class event.

Derived classes cannot raise events of their base classes, so we expose event wrapper methods to accommodate as needed. An array of generic type T to be passed to ItemsProcessed.

Raises the base class event.

Derived classes cannot raise events of their base classes, so we expose event wrapper methods to accommodate as needed. to be passed to ProcessException.

Notifies queue that data was added and/or modified, so it can begin processing data.

Derived classes *must* make sure to call this method after data gets added, so that the process timer can be enabled for intervaled and data processing can begin. To make sure items in the always get processed, this function is expected to be invoked from within a SyncLock of the exposed SyncRoot (i.e., InternalList).

Determines if an item can be processed.

True, if user provided no implementation for the CanProcessItemFunction. Use this function instead of invoking the CanProcessItemFunction pointer directly, since implementation of this delegate is optional. The item T to process. A value indicating whether it can process the item or not.

Determines if all items can be processed.

True, if user provided no implementation for the CanProcessItemFunction. Use this function instead of invoking the CanProcessItemFunction pointer directly, since implementation of this delegate is optional. An array of items of type T. A value indicating whether the process queue can process the items.

Requeues item into according to specified requeue reason.

A generic item of type T to be requeued. The reason the object is being requeued.

Requeues items into according to specified requeue reason.

Array of type T to be requeued. The reason the object is being requeued.

Adds the elements of the specified collection to the end of the .

The collection whose elements should be added to the end of the . The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type. collection is null.

Searches the entire sorted , using a binary search algorithm, for an element using the default comparer and returns the zero-based index of the element.

must be sorted in order for this function to return an accurate result. The object to locate. The value can be null for reference types. The zero-based index of item in the sorted , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of count. The default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T.

Searches the entire sorted , using a binary search algorithm, for an element using the specified comparer and returns the zero-based index of the element.

must be sorted in order for this function to return an accurate result. The object to locate. The value can be null for reference types. The Generic.IComparer implementation to use when comparing elements -or- null to use the default comparer: Generic.Comparer(Of T).Default The zero-based index of item in the sorted , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of count. The default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T.

Searches a range of elements in the sorted , using a binary search algorithm, for an element using the specified comparer and returns the zero-based index of the element.

must be sorted in order for this function to return an accurate result. The zero-based starting index of the range to search. The length of the range to search. The object to locate. The value can be null for reference types. The Generic.IComparer implementation to use when comparing elements -or- null to use the default comparer: Generic.Comparer(Of T).Default The zero-based index of item in the sorted , if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of count. startIndex is outside the range of valid indexes for the -or- count is less than 0 -or- startIndex and count do not specify a valid section in the The default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T.

Converts the elements in the current to another type, and returns a containing the converted elements.

A generic list of the target type containing the converted elements from the current . A Converter delegate that converts each element from one type to another type. converter is null. The generic type used.

Determines whether the contains elements that match the conditions defined by the specified predicate.

True, if the contains one or more elements that match the conditions defined by the specified predicate; otherwise, false. The Predicate delegate that defines the conditions of the elements to search for. match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire .

The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T. The Predicate delegate that defines the conditions of the element to search for. match is null.

Retrieves all elements that match the conditions defined by the specified predicate.

A generic list containing all elements that match the conditions defined by the specified predicate, if found; otherwise, an empty list. The Predicate delegate that defines the conditions of the elements to search for. match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the that extends from the specified index to the last element.

The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The Predicate delegate that defines the conditions of the element to search for. match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the that extends from the specified index to the last element.

The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The zero-based starting index of the search. The Predicate delegate that defines the conditions of the element to search for. startIndex is outside the range of valid indexes for the . match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the that extends from the specified index to the last element.

The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The zero-based starting index of the search. The number of elements in the section to search. The Predicate delegate that defines the conditions of the element to search for. startIndex is outside the range of valid indexes for the -or- count is less than 0 -or- startIndex and count do not specify a valid section in the . match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire .

The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T. The Predicate delegate that defines the conditions of the element to search for. match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire .

The zero-based index of the last occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The Predicate delegate that defines the conditions of the element to search for. match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the that extends from the first element to the specified index.

The zero-based index of the last occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The zero-based starting index of the backward search. The Predicate delegate that defines the conditions of the element to search for. startIndex is outside the range of valid indexes for the . match is null.

Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index.

The zero-based index of the last occurrence of an element that matches the conditions defined by match, if found; otherwise, –1. The number of elements in the section to search. The zero-based starting index of the backward search. The Predicate delegate that defines the conditions of the element to search for. startIndex is outside the range of valid indexes for the -or- count is less than 0 -or- startIndex and count do not specify a valid section in the . match is null.

Performs the specified action on each element of the .

The Action delegate to perform on each element of the . action is null.

Creates a shallow copy of a range of elements in the source .

A shallow copy of a range of elements in the source . The number of elements in the range. The zero-based index at which the range starts. index is less than 0 -or- count is less than 0. index and count do not denote a valid range of elements in the .

Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that extends from the specified index to the last element.

The zero-based index of the first occurrence of item within the range of elements in the that extends from index to the last element, if found; otherwise, –1. The object to locate in the . The value can be null for reference types. The zero-based starting index of the search. index is outside the range of valid indexes for the .

Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the that starts at the specified index and contains the specified number of elements.

The zero-based index of the first occurrence of item within the range of elements in the that starts at index and contains count number of elements, if found; otherwise, –1. The number of elements in the section to search. The object to locate in the . The value can be null for reference types. The zero-based starting index of the search. index is outside the range of valid indexes for the -or- count is less than 0 -or- index and count do not specify a valid section in the .

Inserts the elements of a collection into the at the specified index.

The collection whose elements should be inserted into the . The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type. The zero-based index at which the new elements should be inserted. index is less than 0 -or- index is greater than length. collection is null.

Searches for the specified object and returns the zero-based index of the last occurrence within the entire .

The zero-based index of the last occurrence of item within the entire the , if found; otherwise, –1. The object to locate in the . The value can be null for reference types.

Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that extends from the first element to the specified index.

The zero-based index of the last occurrence of item within the range of elements in the that extends from the first element to index, if found; otherwise, –1. The object to locate in the . The value can be null for reference types. The zero-based starting index of the backward search. index is outside the range of valid indexes for the .

Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the that contains the specified number of elements and ends at the specified index.

The zero-based index of the last occurrence of item within the range of elements in the that contains count number of elements and ends at index, if found; otherwise, –1. The object to locate in the . The value can be null for reference types. The zero-based starting index of the backward search. The number of elements in the section to search. index is outside the range of valid indexes for the -or- count is less than 0 -or- index and count do not specify a valid section in the .

Removes the all the elements that match the conditions defined by the specified predicate.

The number of elements removed from the . The Predicate delegate that defines the conditions of the elements to remove. match is null.

Removes a range of elements from the .

The number of elements to remove. The zero-based starting index of the range of elements to remove. index is less than 0 -or- count is less than 0. index and count do not denote a valid range of elements in the .

Reverses the order of the elements in the entire .

Reverses the order of the elements in the specified range.

The number of elements in the range to reverse. The zero-based starting index of the range to reverse. index and count do not denote a valid range of elements in the . index is less than 0 -or- count is less than 0.

Sorts the elements in the entire , using the default comparer.

The default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T.

Sorts the elements in the entire , using the specified comparer.

The Generic.IComparer implementation to use when comparing elements, or null to use the default comparer: Generic.Comparer.Default. The implementation of comparer caused an error during the sort. For example, comparer might not return 0 when comparing an item with itself. the comparer is null and the default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T.

Sorts the elements in a range of elements in the , using the specified comparer.

The length of the range to sort. The zero-based starting index of the range to sort. The Generic.IComparer implementation to use when comparing elements, or null to use the default comparer: Generic.Comparer.Default. The implementation of comparer caused an error during the sort. For example, comparer might not return 0 when comparing an item with itself. the comparer is null and the default comparer, Generic.Comparer.Default, cannot find an implementation of the IComparable generic interface or the IComparable interface for type T. index is less than 0 -or- count is less than 0.

Sorts the elements in the entire , using the specified comparison.

The comparison to use when comparing elements. The implementation of comparison caused an error during the sort. For example, comparison might not return 0 when comparing an item with itself. comparison is null.

Determines whether every element in the matches the conditions defined by the specified predicate.

True, if every element in the matches the conditions defined by the specified predicate; otherwise, false. If the has no elements, the return value is true. The Predicate delegate that defines the conditions to check against the elements. match is null.

Adds an item to the .

The item to add to the .

Inserts an element into the at the specified index.

The object to insert. The value can be null for reference types. The zero-based index at which item should be inserted. index is less than 0 -or- index is greater than length.

Copies the entire to a compatible one-dimensional array, starting at the beginning of the target array.

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

Searches for the specified object and returns the zero-based index of the first occurrence within the entire .

The zero-based index of the first occurrence of item within the entire , if found; otherwise, –1. The object to locate in the . The value can be null for reference types.

Removes all elements from the .

Removes the first occurrence of a specific object from the .

True, if item is successfully removed; otherwise, false. This method also returns false if item was not found in the . The object to remove from the . The value can be null for reference types.

Removes the element at the specified index of the .

The zero-based index of the element to remove. index is less than 0 -or- index is equal to or greater than length.

Handles standard processing of a single item.

A generic item of type T to be processed.

Handles standard processing of multiple items.

Array of type T.

Processes queued items on an interval.

The sender object of the item. Arguments for the elapsed event.

Processes next item in queue, one at a time (i.e., ProcessingStyle = OneAtATime).

Processes next items in an array of items as a group (i.e., ProcessingStyle = ManyAtOnce).

Creates a new asynchronous with the default settings: ProcessInterval = 100, MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. A ProcessQueue object based on type T.

Creates a new asynchronous with the default settings: ProcessInterval = 100, MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new asynchronous with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. An value that determines the maximum number of threads used to process items. A ProcessQueue object based on type T.

Creates a new asynchronous with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. An value that determines the maximum number of threads used to process items. A ProcessQueue object based on type T.

Creates a new asynchronous using specified settings.

Delegate that processes one item at a time. a value which represents the process interval in milliseconds. An value that determines the maximum number of threads used to process items. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new asynchronous using specified settings.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. a value which represents the process interval in milliseconds. An value that determines the maximum number of threads used to process items. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new synchronous (i.e., single process thread) with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. A ProcessQueue object based on type T.

Creates a new synchronous (i.e., single process thread) with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new synchronous (i.e., single process thread) using specified settings.

Delegate that processes one item at a time. a value which represents the process interval in milliseconds. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new synchronous (i.e., single process thread) using specified settings.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. a value which represents the process interval in milliseconds. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new real-time with the default settings: ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. A ProcessQueue object based on type T.

Creates a new real-time with the default settings: ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new real-time using specified settings.

Delegate that processes one item at a time. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new real-time using specified settings.

Delegate that processes one item at a time. Delegate which determines whether an item can be processed. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item with the default settings: ProcessInterval = 100, MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item with the default settings: ProcessInterval = 100, MaximumThreads = 5, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. An value that determines the maximum number of threads used to process items. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. An value that determines the maximum number of threads used to process items. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item using specified settings.

Delegate that defines a method to process multiple items at once. a value which represents the process interval in milliseconds. An value that determines the maximum number of threads used to process items. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new asynchronous, bulk item using specified settings.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. a value which represents the process interval in milliseconds. An value that determines the maximum number of threads used to process items. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new synchronous, bulk item (i.e., single process thread) with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. A ProcessQueue object based on type T.

Creates a new synchronous, bulk item (i.e., single process thread) with the default settings: ProcessInterval = 100, ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new synchronous, bulk item (i.e., single process thread) using specified settings.

Delegate that defines a method to process multiple items at once. a value which represents the process interval in milliseconds. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new synchronous, bulk item (i.e., single process thread) using specified settings.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. a value which represents the process interval in milliseconds. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new real-time, bulk item with the default settings: ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. A ProcessQueue object based on type T.

Creates a new real-time, bulk item with the default settings: ProcessTimeout = Infinite, RequeueOnTimeout = False, RequeueOnException = False.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. A ProcessQueue object based on type T.

Creates a new real-time, bulk item using specified settings.

Delegate that defines a method to process multiple items at once. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Creates a new real-time, bulk item using specified settings.

Delegate that defines a method to process multiple items at once. Delegate which determines whether an item can be processed. The number of seconds before a process should timeout. A value that indicates whether a process should requeue an item on timeout. A value that indicates whether a process should requeue after an exception. A ProcessQueue object based on type T.

Represents the statistics of a .

Gets indicator that the is currently enabled.

Gets indicator that the is actively processing items.

Gets the interval, in milliseconds, on which new items begin processing.

Gets the maximum time, in milliseconds, allowed for processing an item.

Gets the current for the (i.e., synchronous or asynchronous).

Gets the item for the (i.e., one at a time or many at once).

Gets the total amount of time, in seconds, that the process has been active.

Gets the current number of active threads.

Gets the number of elements queued for processing in the .

Gets the total number of items currently being processed.

Gets the total number of items processed so far.

Task scheduler that limits the number of tasks that can execute in parallel at any given time.

Creates a new instance of the class with a and a maximum concurrency level equal to the number of processors on the current machine.

Creates a new instance of the class with a maximum concurrency level equal to the number of processors on the current machine.

Factory function for creating the synchronized operations to be used for processing tasks.

Creates a new instance of the class with a .

The initial value for .

Creates a new instance of the class.

Factory function for creating the synchronized operations to be used for processing tasks. The initial value for .

Gets the number of threads that are currently executing tasks concurrently.

Gets the maximum number of threads that can be executing tasks concurrently.

Sets the maximum number of threads that can be executing tasks concurrently.

The maximum concurrency level.

Queues a to the scheduler.

The to be queued.

Determines whether the provided can be executed synchronously in this call, and if it can, executes it.

The to be executed. A 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 queuing it. A value indicating whether the task was executed inline.

For debugger support only, generates an enumerable of instances currently queued to the scheduler waiting to be executed.

An enumerable that allows a debugger to traverse the tasks currently queued to this scheduler.

Represents a wait-by-key async signaling operation that can work with multiple concurrent waiters per key. Multiple callers await a task associated with a key; another single thread then signals completion with a result or failure with an exception for that key.

Pruning happens periodically to avoid orphaned waiters when all callers timeout from no signal. Key type, e.g., a . Result type delivered to all waiters when signaled.

Creates a new instance of the class.

Internal for pruning orphaned waiters.
Use null for default pruning interval of 1 minute.
Use for no pruning. Key comparer; use null for default.

Gets the number of pending keys that have waiters.

Releases all the resources used by the object.

Waits synchronously for the specified to be signaled or failed. Multiple concurrent waiters on the same key complete together.

Key to wait on. Optional token to cancel or timeout the wait. A tuple where: result is the signaled result when successful; otherwise default. ex is null on success; otherwise the exception that caused the failure, including when canceled. Thrown if the instance has been disposed. A failure triggered by returns (default, ex) where ex is the exception provided to .Cancellation is treated like a failure where returned ex is an . For asynchronous waiting, use .

Asynchronously waits for to be signaled (or failed). Multiple concurrent waiters on the same key complete together.

Key to wait on. Optional token to cancel or timeout the wait. A task that completes when signaled, failed, or canceled. Thrown if the instance has been disposed. We never remove the per-key bucket on cancellation—only individual waiters. Buckets are removed on / or by periodic pruning. A mapping-stability check ensures we never add to an orphaned bucket.

Tries to signal all current waiters for with . New waiters added after this call for same key will await a subsequent signal/fail.

Key to signal. Result to signal to all waiters. true if the signal was successful; otherwise, false if there were no waiters for the key. Thrown if the instance has been disposed.

Signals all current waiters for with . New waiters added after this call for same key will await a subsequent signal/fail.

Key to signal. Result to signal to all waiters. The number of waiters released. Thrown if the instance has been disposed.

Tries to fail all current waiters for with . New waiters added after this call for same key will await a subsequent signal/fail.

Key to fail. Exception to signal to all waiters. true if the fail was successful; otherwise, false if there were no waiters for the key. Thrown if the instance has been disposed.

Fails all current waiters for with . New waiters added after this call for same key will await a subsequent signal/fail.

Key to fail. Exception to signal to all waiters. The number of waiters released. Thrown if the instance has been disposed.

Represents a set of statistics gathered about the execution time of actions on a logical thread.

Gets the execution time of the longest running action.

Gets the execution time of the shortest running action.

Gets the total execution time of all actions executed on the logical thread.

Gets the total number of actions executed on the logical thread.

Updates the statistics based on the execution time of a single action.

The execution time of the action.

Represents a thread of execution to which actions can be dispatched from other threads.

This class provides a simple alternative to synchronization primitives such as wait handles and locks. Actions dispatched to a logical thread will be processed synchronously as though it was executed as consecutive method calls. All such actions can be dispatched from any thread in the system so method calls coming from multiple threads can be easily synchronized without locks, loops, wait handles, or timeouts. Note that the implements its own thread pool to execute tasks pushed to logical threads. Executing long-running processes or using synchronization primitives with high contention or long timeouts can hinder the logical thread schedulers ability to schedule the actions of other logical threads. Like other thread pool implementations, you can mitigate this by increasing the maximum thread count of the logical thread scheduler, however it is recommended to avoid using synchronization primitives and instead synchronize those operations by running them as separate actions on the same logical thread.

Handler for unhandled exceptions on the thread.

Creates a new instance of the class.

Creates a new instance of the class.

The that created this thread. is null.

Gets the number of levels of priority supported by this logical thread.

Gets a flag that indicates whether the logical thread has any unprocessed actions left in its queue.

Gets or sets the priority at which the logical thread is queued by the scheduler.

Gets the priority of the next action to be processed on this logical thread.

Gets or sets the cancellation token for the next time the thread's actions will be executed by the scheduler.

Pushes an action to the logical thread.

The action to be executed on this thread.

Pushes an action to the logical thread.

The priority the action should be given when executing actions on the thread (higher numbers have higher priority). The action to be executed on this thread. is outside the range between 1 and .

Clears all actions from the logical thread.

Samples the statistics, providing current statistic values and resetting statistic counters.

The current statistic values.

Pulls an action from the logical thread's internal queue to be executed on a physical thread.

An action from the logical thread's internal queue.

Attempts to activate the thread at the given priority.

The priority at which to activate the thread. True if the thread's priority needs to be changed to the given priority; false otherwise.

Completely deactivates the thread, making it available for reactivation at any priority.

Returns the thread local object with the given ID.

The key used to look up the thread local object. The value of the thread local object with the given ID.

Sets the value of the thread local object with the given ID.

The key used to look up the thread local object. The new value for the thread local object.

Updates the statistics based on the execution time of a single action.

The execution time of the action.

Raises the event.

The unhandled exception. True if there are any handlers attached to this event; false otherwise.

Gets the logical thread that is currently executing.

Defines extensions for the class.

Creates an awaitable that ensures the continuation is running on the logical thread.

The thread to join. A context that, when awaited, runs on the logical thread.

Creates an awaitable that ensures the continuation is running on the logical thread.

The thread to join. The priority of the continuation when completing asynchronously. A context that, when awaited, runs on the logical thread.

Creates an awaitable that asynchronously yields to a new action on the logical thread when awaited.

The thread to yield to. A context that, when awaited, will transition to a new action on the logical thread.

Creates an awaitable that asynchronously yields to a new action on the logical thread when awaited.

The thread to yield to. The priority of the continuation. A context that, when awaited, will transition to a new action on the logical thread.

Provides an awaitable context for switching into a target environment.

This type is intended for compiler use only.

Provides an awaiter that switches into a target environment.

This type is intended for compiler use only.

Creates a new instance of the class.

The awaitable that spawned this awaiter.

Gets whether a yield is not required.

This property is intended for compiler user rather than use directly in code.

Posts the back to the current context.

The action to invoke asynchronously. The argument is null.

Ends the await operation.

Creates a new instance of the class.

The thread on which to push continuations. The priority of continuations pushed to the thread. Force continuations to complete asynchronously.

Gets an awaiter for this .

An awaiter for this awaitable. This method is intended for compiler user rather than use directly in code.

Represents a slot in the thread local memory space of each logical thread.

Creates a new instance of the class.

Creates a new instance of the class.

Factory to produce the initial value when accessing uninitialized values.

Releases the unmanaged resources before the object is reclaimed by .

Gets or sets the thread local object associated with the current logical thread.

Gets a flag that indicates whether this object has been disposed.

Releases all the resources used by the object.

Executes the given action in a protected code block that ensures all unmanaged resources get cleaned up after a call to .

The action to be executed.

Executes the given function in a protected code block that ensures all unmanaged resources get cleaned up after a call to .

The function to be executed.

Attempts to get the instance of this slot from the current logical thread.

An instance of this slot. True if an instance of this slot is successfully retrieved from the current logical thread.

Releases the unmanaged resources used by the object and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Attaches logic to dispose of the slot in the currently executing logical thread.

Invokes the event handler.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Synchronized operation that executes on a logical thread.

This synchronized operation optionally supports a different usage pattern which will allow for asynchronous loops and signals to be passed between threads throughout an operation. The following is an example of how to implement a simple asynchronous loop between two threads using this class. Note that when used, the pattern requires more diligence on the user's part for handling exceptions and signaling when the operation is complete: LogicalThread thread1 = new LogicalThread(); LogicalThread thread2 = new LogicalThread(); // Create logical thread operation with manually controlled call to RunIfPending LogicalThreadOperation operation = new LogicalThreadOperation(thread1, DoOperation, false); private void DoOperation() { ExecuteOnThread1(); thread2.Push(() => operation.ExecuteAction(() => { ExecuteOnThread2(); operation.RunIfPending(); })); });

Creates a new instance of the class.

The thread on which to execute the operation's action. The action to be executed. Set to true to execute automatically; otherwise, set to false for user controlled call timing.

Creates a new instance of the class.

The thread on which to execute the operation's action. The action to be executed. The priority with which the action should be executed on the logical thread. Set to true to execute automatically; otherwise, set to false for user controlled call timing. is outside the range between 1 and .

Gets a value to indicate whether the operation is currently executing actions.

Gets a value to indicate whether the operation has an additional operation that is pending execution after the currently running operation has completed.

Gets flag that determines if will be called automatically.

Gets or sets default priority for logical thread operation.

is outside the range between 1 and . Updates to default priority will only take effect during next call.

Executes the action on the current thread or marks the operation as pending if the operation is already running.

When the operation is marked as pending, it will run again at the next call to . This can be useful if an update to an object's state has invalidated the operation that is currently running and will therefore need to be run again.

Executes the action on another thread or marks the operation as pending if the operation is already running.

When the operation is marked as pending, it will run again at the next call to . This can be useful if an update to an object's state has invalidated the operation that is currently running and will therefore need to be run again.

Attempts to execute the action on the current thread. Does nothing if the operation is already running.

Attempts to execute the action on another thread. Does nothing if the operation is already running.

Starts the operation over at the beginning if the operation is pending or sets the operation state back to not running so it can run again.

This method must be called at the end of an operation in order to set the state of the operation back to running or not running so that the operation can run again. The existence of this method makes this implementation different from other synchronized operations in that it requires more diligence on the user's part to signal when the operation is complete. In turn, this allows the user to implement complex operations that may involve asynchronous loops and signaling patterns that would not be possible with the interface.

Executes an action once on the current thread.

to run on current thread. This method provides exception handling for the action passed into this method with a couple of guarantees. The first is that regardless of what thread is executing the action passed into this method, the exception will be raised on the thread that the logical operation runs on. The second is that the RunIfPending method will be called if an exception does occur in the given action.

If the operation is running, the action has yet to be executed, and the given priority level differs from the queued action's priority level, this method will requeue the action at the given priority level.

The priority at which the current operation should be requeued.

Manages synchronization of actions by dispatching actions to logical threads to be processed synchronously.

Triggered when an action managed by this synchronization manager throws an exception.

Creates a new instance of the class.

The number of levels of priority supported by this logical thread scheduler. is less than or equal to zero.

Gets or sets the target for the maximum number of physical threads managed by this synchronization manager at any given time.

Gets or sets the flag that determines whether the threads in the schedulers thread pool should be background threads.

Gets the number of levels of priority supported by this scheduler.

Gets the current number of active physical threads.

Creates a new logical thread whose execution is managed by this scheduler.

A new logical thread managed by this scheduler.

Signals the manager when a logical thread has new actions to be processed.

The thread with new actions to be processed. The priority at which the thread is being signaled.

Activates a new physical thread if the thread count has not yet reached its maximum limit.

Starts a new physical thread to process actions from logical threads.

Processes the next available task from the least recently processed logical thread that is available for processing.

Queues the given thread for execution.

The thread to be queued for execution.

Attempts to execute the given action.

The action to be executed.

Decrements the thread count upon deactivation of a physical thread.

Attempts to handle the exception via either the logical thread's exception handler or the schedulers exception handler.

The unhandled exception thrown by an action on the logical thread. True if the exception could be handled; false otherwise.

Raises the event.

The unhandled exception. True if there are any handlers attached to this event; false otherwise.

The namespace organizes all Gemstone library functionality related to threading. The root threading namespace also includes common threading classes, e.g., .

A rate limiting system based on tokes.

Creates a

The number of tokens per second that can be generated. Must be greater than zero and less than 1 billion The maximum number of tokens in the queue. Must be at least 1

Updates the limits associated with this rate limiter. Note, after this update, the tokens will be completely resupplied.

The number of tokens per second that can be generated. Must be greater than zero and less than 1 billion The maximum number of tokens in the queue. Must be at least 1

Attempts to take a token from the rate limiter.

true if token was successfully taken, False if all tokens were consumed.

Represents a fast, lightweight reader/writer lock that uses spinning to perform locking. No recursive acquires or upgradable locks are allowed (i.e., all entered locks must be exited before entering another lock).

This reader/writer lock uses to spin the CPU instead of engaging event based locking. As a result it should only be used in cases where lock times are expected to be very small, reads are very frequent and writes are rare. If hold times for write locks can be lengthy, it will be better to use instead to avoid unnecessary CPU utilization due to spinning incurred by waiting reads.

Enters the lock in write mode.

Upon successful acquisition of a write lock, use the finally block of a try/finally statement to call . One should be called for each .

Exits write mode.

Enters the lock in read mode.

Upon successful acquisition of a read lock, use the finally block of a try/finally statement to call . One should be called for each .

Exits read mode.

Cannot exit read lock when there are no readers.

Specifies the threading mode to use for the

A dedicated thread that is a foreground thread.

A dedicated thread that is a background thread.

A background thread from the thread pool.

Metadata about why this worker was called.

A normal run was scheduled.

Dispose was called and execution will terminate after this function call.

Represents a way to schedule a task to be executed on a separate thread immediately or after a given time delay.

Occurs every time the task should run.

Occurs right before this task is disposed.

Occurs when or event throws an exception.

Creates a .

The manner in which the scheduled task executes. The thread priority to assign if a dedicated thread is used. This is ignored if using the thread-pool. Adds a handler to that requires this class to be disposed when the application is shutdown. Note: If this object has been garbage collected, this will have no effect.

Cleans up the thread since that class likely will never be garbage collected.

For foreground threads, a shutdown handler is registered to dispose of the Thread so it doesn't keep the process running. However, for the Logger, shutting down this thread will prevent shutdown messages from showing up in the logger. By calling this method, it declares that the coder will dispose of this class when it is finished and does not want the Shutdown handler to do it.

Starts the task immediately, or if one was scheduled, starts the scheduled task immediately

If this is called after a the timer will be canceled and the process will still start immediately. This method is safe to call from any thread, including the worker thread. If disposed, this method will no nothing.

Starts a timer to run the task after a provided interval.

the delay in milliseconds before the task should run If a timer is currently pending, this function will do nothing. Do not use this function to reset or restart an existing timer. If called while working, a subsequent timer will be scheduled, but delay will not start until after the worker has completed. This method is safe to call from any thread, including the worker thread. If disposed, this method will no nothing.

Starts the disposing process of exiting the worker thread.

Callback will be invoked one more time. Duplicate calls are ignored. Unless called from the worker thread, this method will block until the dispose has successfully completed.

Represents a timer class that will group registered timer event callbacks that operate on the same interval in order to optimize thread pool queuing.

Externally the operations similar to the . Internally the timer pools callbacks with the same into a single timer where each callback is executed on the same thread, per instance of the . Any long running callbacks that have a risk of long delays should not use as this will effect the reliability of all of the other instances for a given .

Occurs when the timer interval elapses.

Initializes a new instance of the .

The scheduler to use. The interval of the timer, default is 100.

Gets or sets flag that indicates whether the should raise the event only once false or repeatedly true.

true the should raise the event each time the interval elapses; otherwise, false if it should raise the event only once, after the first time the interval elapses. The default is true.

Gets or sets flag that indicates whether the should raise the event.

true if the should raise the event; otherwise, false. The default is false.

Gets or sets the interval at which to raise the event.

The time, in milliseconds, between events. The value must be greater than zero, and less than or equal to . The default is 100 milliseconds.

Gets the current status details about object providing status information.

Stops the timer.

Stops the timer and prevents reuse of the class.

Starts raising the event by setting to true.

Stops raising the event by setting to false.

Callback from .

The time that the callback was signaled.

Represents a timer manager which is the scheduler of .

A with the same scheduler will use the same ThreadPool thread to process all of the instances in series when they have a common interval. Call order, based on registration sequence, will be preserved. Total number of callbacks that have occurred Count of the number of timer callbacks that exists in this factory

Creates a new instance of the class.

Gets flag that determines if this instance has been disposed.

Creates a using the current .

The interval of the timer, default is 100. A shared timer instance that fires at the given interval.

Attempts to get status of for specified .

The interval of the timer. Timer status.

Registers the given callback with the timer running at the given interval.

The interval at which to run the timer. The action to be performed when the timer is triggered. The weak reference callback that will be executed when this timer fires. To unregister the callback, call .

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

The order in which the specified callback should occur when shutting down.

This queue is processed first. Unless there is a compelling reason to execute first, select the Default one.

This shutdown order occurs after First, but before Last.

This queue is processed last. Items such as flushing application logs should go here.

This class will monitor the state to the application and raise events when it detects that the application is about to shut down.

This class is duplicated here from the Gemstone.Diagnostics project as an internal class to avoid a circular dependency.

Gets if this process is shutting down.

Gets if this process has already shut down.

Initializes the shutdown handler. This is recommended to put in main loop of the program, but it is not critical.

Attempts Registers a callback that will be called when the application is shutdown.

the callback when the shutdown occurs the order that the callback will occur.

Requests that certain components initiate a safe shutdown.

This method should only be called when the main thread exits. Calling this outside of the application exiting could result in unpredictable behavior.

The namespace provides classes for strands, which are FIFO based synchronized task queues, e.g., and .

Schedules tasks in a collection of FIFO queues and executes them in priority order.

Creates a new instance of the class with a .

Creates a new instance of the class with a .

The number of priority levels to be pre-allocated by the priority queue.

Creates a new instance of the class.

Factory function for creating the synchronized operation to be used for processing tasks.

Creates a new instance of the class.

Factory function for creating the synchronized operation to be used for processing tasks. The number of priority levels to be pre-allocated by the priority queue.

Gets a used to queue tasks at a specific priority.

The priority at which tasks should be queued by the returned . Higher numbers are higher in priority! A that queues tasks into the strand at the given priority. is less than zero For a strand with n priorities, it is recommended to use priority levels between 0 and n-1 inclusive.

Schedules tasks in a FIFO queue and executes them in a synchronized asynchronous loop.

Creates a new instance of the class with a .

Creates a new instance of the class.

Factory function for creating the synchronized operation to be used for processing tasks.

Indicates the maximum concurrency level this is able to support.

Queues a to the scheduler.

The to be queued.

Attempts to execute a task inline, but only if this method is called on the processing thread to avoid parallel execution of tasks.

The 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 queuing it. A Boolean value indicating whether the task was executed inline. Inline execution allows tasks to skip the line and run out of order. The only reason inline execution is supported at all is to avoid a common case of deadlocking where a task is queued in advance of another task that it depends on (via , for instance). However, deadlocks can still occur when waiting on tasks scheduled by a different strand. To avoid out-of-order execution and deadlocks, be very careful about using API calls that wait on tasks.

Attempts to dequeue a that was previously queued to this scheduler.

The to be dequeued. A Boolean denoting whether the task argument was successfully dequeued.

For debugger support only, generates an enumerable of instances currently queued to the scheduler waiting to be executed.

An enumerable that allows a debugger to traverse the tasks currently queued to this scheduler.

Provides factory functions for creating new objects.

The default used by this factory for creating new objects.

Creates a new instance of the class.

The type of the result value associated with the . A new object of type .

Creates a new instance of the class.

The type of the result value associated with the . The state to use as the underlying 's . A new object of type .

Gets if StartDisposal() method is the only item that triggered this run.

State variables for the internal state machine.

Indicates that the task is not running.

Indicates that the task is scheduled to execute after a user specified delay

Indicates the task has been queue for immediate execution, but has not started running yet.

Once in a running state, only the worker thread can change its state.

Once reaching this state, the effect of RunAgain being set will no longer be valid.

A disposed state

A value less than 0 means false.

Same as Start() except notifies on the callback during a race condition that this is the one that was first to schedule the task.

For foreground threads, a shutdown handler is registered to dispose of the Thread so it doesn't keep the process running. However, for the Logger, shutting down this thread will prevent shutdown messages from showing up in the logger. By calling this method, it declares that the coder will dispose of this class when it is finished and does not want the Shutdown handler to do it.

Handle that is created when telling the threadpool to do a delayed start.

The reset event that allows the timer to be short circuited.

Defines extension functions related to manipulation wait handle objects.

Waits for all the specified elements to receive a signal.

Collection of elements to operate on. A to observe, if any. true when every element has received a signal; otherwise the method never returns unless cancelled. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Waits for all the specified elements to receive a signal.

Collection of elements to operate on. A to observe. true when every element has received a signal; otherwise the method never returns unless cancelled. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Waits for all the specified elements to receive a signal, using an integer value to specify the maximum time interval,in milliseconds, to wait.

Collection of elements to operate on. The number of milliseconds to wait, or (-1) to wait indefinitely. A to observe, if any. true when every element has received a signal; otherwise false. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Waits for all the specified elements to receive a signal, using an integer value to specify the maximum time interval,in milliseconds, to wait.

Collection of elements to operate on. The number of milliseconds to wait, or (-1) to wait indefinitely. A to observe. true when every element has received a signal; otherwise false. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Waits for all the specified elements to receive a signal, using a value to specify the maximum time interval to wait.

Collection of elements to operate on. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds, to wait indefinitely. A to observe, if any. true when every element has received a signal; otherwise false. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Waits for all the specified elements to receive a signal, using a value to specify the maximum time interval to wait.

Collection of elements to operate on. A that represents the number of milliseconds to wait, or a that represents -1 milliseconds, to wait indefinitely. A to observe. true when every element has received a signal; otherwise false. is null. Using will cause all elements to be upgraded to a standard , these overloads allow similar functionality without incurring unconditional inflation of the underlying .

Provides a weak referenced delegate.

This class will store the information necessary so the callback object will have a weak reference to it. This information is compiled an can be quickly executed without the overhead of using reflection.

Creates a WeakAction.

The callback.

Attempts to invoke the delegate to a weak reference object.

true if successful; otherwise, false.

Clears callback target.

Provides a weak referenced delegate.

This class will store the information necessary so the callback object will have a weak reference to it. This information is compiled an can be quickly executed without the overhead of using reflection.

Creates a WeakAction.

The callback.

Attempts to invoke the delegate to a weak reference object.

true if successful; otherwise, false.

Clears callback target.