System.Threading.Tasks.Dataflow

Provides a set of static (Shared in Visual Basic) methods for working with dataflow blocks.

Links the to the specified .

The source from which to link. The to which to connect the source. An IDisposable that, upon calling Dispose, will unlink the source from the target. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Links the to the specified using the specified filter.

The source from which to link. The to which to connect the source. The filter a message must pass in order for it to propagate from the source to the target. An IDisposable that, upon calling Dispose, will unlink the source from the target. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Links the to the specified using the specified filter.

The source from which to link. The to which to connect the source. The filter a message must pass in order for it to propagate from the source to the target. The options to use to configure the link. An IDisposable that, upon calling Dispose, will unlink the source from the target. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Provides a synchronous filter for use in filtered LinkTos.

Specifies the type of data being filtered.

The source connected with this filter.

The target with which this block is associated.

The predicate provided by the user.

Initializes the filter passthrough.

The source connected to this filter. The target to which filtered messages should be passed. The predicate to run for each message.

Runs the user-provided predicate over an item in the correct execution context.

The item to evaluate. true if the item passed the filter; otherwise, false.

Manually closes over state necessary in FilteredLinkPropagator.

The input to be filtered.

The predicate function.

The result of the filtering operation.

Initializes the predicate state.

The input to be filtered. The predicate function.

Runs the predicate function over the input and stores the result into the output.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

A instance that represents the header of the message being offered. The value of the message being offered. The offering the message. This may be null (Nothing in Visual Basic). true if the target must call ConsumeMessage synchronously during the call to OfferMessage, prior to returning , in order to consume the message. false if the target wanting to accept the message should not call ConsumeMessage, and should isntead simply return DataflowMessageStatus.Accepted. The status of the offered message. If the message was accepted by the target, is returned, and the source should no longer use the offered message, as it is now owned by the target. If the message was postponed by the target, is returned as a notification that the target may later attempt to consume or reserve the message; in the meantime, the source still owns the message and may offer it to other blocks. If the target would have otherwise postponed but source was null, is instead returned. If the target tried to accept the message but missed it due to the source delivering the message to another target or simply discarding it, is returned. If the target chose not to accept the message, is returned. If the target chose not to accept the message and will never accept another message from this source, is returned. The is not valid. may only be true if provided with a non-null .

Passes the ownership of the message identified by the from this instance to the .

The of the message that is to be consumed. The for which the message is to be consumed. True if the message was successfully consumed. False otherwise. The value of the consumed message. This may correspond to a different instance than was previously reserved and passed as the to . The consuming must use the returned value instead of the value passed as messageValue through . If the message requested is not available, the return value will be null (Nothing in Visual Basic). The is not valid. The is null (Nothing in Visual Basic). The for which the message is to be consumed need not be linked from this instance. Moreover, this instance may have never offered the message directly to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

The of the message that is to be reserved. The for which the message is to be reserved. true if the message was successfully reserved; otherwise, false. The is not valid. The is null (Nothing in Visual Basic). The for which the message is to be reserved need not be linked from this instance. Moreover, this instance may have never offered the message directly to the . If true is returned, either or for this message must be subsequently called with the same and . Failure to do so may result in the source being unable to propagate any further messages to any target. must not be called while the target is holding any internal locks. Doing so will violate the lock hierarchy necessary to avoid deadlocks in a dataflow network.

Releases the right to pass the ownership of the message identified by the from this to the .

The of the reserved message. The that currently holds the reservation. The is not valid. The is null (Nothing in Visual Basic). The did not have the message reserved. The that holds the reservation need not be linked from this instance. Moreover, this instance may have never offered the message directly to the . It is required that this message has been previously reserved for the same .

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

A dataflow block is considered completed when it is not currently processing a message and when it has guaranteed that it will not process any more messages. The returned Task will transition to a completed state when the associated block has completed. It will transition to the RanToCompletion state when the block completes its processing successfully according to the dataflow block’s defined semantics, it will transition to the Faulted state when the dataflow block has completed processing prematurely due to an unhandled exception, and it will transition to the Canceled state when the dataflow block has completed processing prematurely due to receiving a cancellation request. If the task completes in the Faulted state, its Exception property will return an containing the one or more exceptions that caused the block to fail.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

After Complete has been called on a dataflow block, that block will complete (such that its task will enter a final state) after it has processed all previously available data. Complete will not block waiting for completion to occur, but rather will initiate the request; to wait for completion to occur, the task may be used.

Causes the to complete in a state.

The that caused the faulting. The is null (Nothing in Visual Basic). After Fault has been called on a dataflow block, that block will complete (such that its task will enter a final state). Faulting a block, as with canceling a block, causes buffered messages (unprocessed input messages as well as unoffered output messages) to be lost.

Links the to the specified .

The to which to connect this source. A instance that configures the link. An IDisposable that, upon calling Dispose, will unlink the source from the target. is null (Nothing in Visual Basic) or is null (Nothing in Visual Basic).

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for a filter.

The filter.

Initializes the debug view.

The filter to view.

The linked target for this filter.

Posts an item to the .

Specifies the type of data accepted by the target block. The target block. The item being offered to the target. true if the item was accepted by the target block; otherwise, false. This method will return once the target block has decided to accept or decline the item, but unless otherwise dictated by special semantics of the target block, it does not wait for the item to actually be processed (for example, will return from Post as soon as it has stored the posted item into its input queue). From the perspective of the block's processing, Post is asynchronous. For target blocks that support postponing offered messages, or for blocks that may do more processing in their Post implementation, consider using SendAsync, which will return immediately and will enable the target to postpone the posted message and later consume it after SendAsync returns.

Asynchronously offers a message to the target message block, allowing for postponement.

Specifies the type of the data to post to the target. The target to which to post the data. The item being offered to the target. A that represents the asynchronous send. If the target accepts and consumes the offered element during the call to SendAsync, upon return from the call the resulting will be completed and its Result property will return true. If the target declines the offered element during the call, upon return from the call the resulting will be completed and its Result property will return false. If the target postpones the offered element, the element will be buffered until such time that the target consumes or releases it, at which point the Task will complete, with its indicating whether the message was consumed. If the target never attempts to consume or release the message, the returned task will never complete. The is null (Nothing in Visual Basic).

Asynchronously offers a message to the target message block, allowing for postponement.

Specifies the type of the data to post to the target. The target to which to post the data. The item being offered to the target. The cancellation token with which to request cancellation of the send operation. A that represents the asynchronous send. If the target accepts and consumes the offered element during the call to SendAsync, upon return from the call the resulting will be completed and its Result property will return true. If the target declines the offered element during the call, upon return from the call the resulting will be completed and its Result property will return false. If the target postpones the offered element, the element will be buffered until such time that the target consumes or releases it, at which point the Task will complete, with its indicating whether the message was consumed. If the target never attempts to consume or release the message, the returned task will never complete. If cancellation is requested before the target has successfully consumed the sent data, the returned task will complete in the Canceled state and the data will no longer be available to the target. The is null (Nothing in Visual Basic).

Provides a source used by SendAsync that will buffer a single message and signal when it's been accepted or declined.

This source must only be passed to a single target, and must only be used once.

The target to offer to.

The buffered message.

CancellationToken used to cancel the send.

Registration with the cancellation token.

The cancellation/completion state of the source.

No cancellation registration is used.

A cancellation token has been registered.

The message has been reserved. Only used if a cancellation token is in play.

Completion is now in progress. Only used if a cancellation token is in play.

Initializes the source.

The target to offer to. The message to offer and buffer. The cancellation token with which to cancel the send.

Finalizer that completes the returned task if all references to this source are dropped.

Completes the source in an "Accepted" state.

true to accept asynchronously; false to accept synchronously.

Completes the source in an "Declined" state.

true to decline asynchronously; false to decline synchronously.

Completes the source in faulted state.

The exception with which to fault. true to fault asynchronously; false to fault synchronously.

Completes the source in canceled state.

true to fault asynchronously; false to fault synchronously.

Executes a completion action.

The action to execute, passed the state. The state to pass into the delegate. true to execute the action asynchronously; false to execute it synchronously. async should be true if this is being called on a path that has the target on the stack, e.g. the target is calling to ConsumeMessage. We don't want to block the target indefinitely with any synchronous continuations off of the returned send async task.

Offers the message to the target asynchronously.

Cached delegate used to cancel a send in response to a cancellation request.

Attempts to cancel the source passed as state in response to a cancellation request.

A weak reference to the SendAsyncSource. A weak reference is used to prevent the source from being rooted in a long-lived token.

Offers the message to the target synchronously.

Called by the target to consume the buffered message.

Called by the target to reserve the buffered message.

Called by the target to release a reservation on the buffered message.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Links the to the specified .

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the source.

The source.

Initializes the debug view.

The source to view.

The target to which we're linked.

The message buffered by the source.

The Task represented the posting of the message.

Attempts to synchronously receive an item from the .

The source from which to receive. The item received from the source. true if an item could be received; otherwise, false. This method does not wait until the source has an item to provide. It will return whether or not an element was available.

Asynchronously receives a value from the specified source.

Specifies the type of data contained in the source. The source from which to asynchronously receive. A that represents the asynchronous receive operation. When an item is successfully received from the source, the returned task will be completed and its Result will return the received item. If an item cannot be retrieved, because the source is empty and completed, the returned task will be canceled. The is null (Nothing in Visual Basic).

Asynchronously receives a value from the specified source.

Specifies the type of data contained in the source. The source from which to asynchronously receive. The which may be used to cancel the receive operation. A that represents the asynchronous receive operation. When an item is successfully received from the source, the returned task will be completed and its Result will return the received item. If an item cannot be retrieved, either because cancellation is requested or the source is empty and completed, the returned task will be canceled. The is null (Nothing in Visual Basic).

Asynchronously receives a value from the specified source.

Specifies the type of data contained in the source. The source from which to asynchronously receive. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. A that represents the asynchronous receive operation. When an item is successfully received from the source, the returned task will be completed and its Result will return the received item. If an item cannot be retrieved, either because the timeout expires or the source is empty and completed, the returned task will be canceled. The is null (Nothing in Visual Basic). timeout is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Asynchronously receives a value from the specified source.

Specifies the type of data contained in the source. The source from which to asynchronously receive. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. The which may be used to cancel the receive operation. A that represents the asynchronous receive operation. When an item is successfully received from the source, the returned task will be completed and its Result will return the received item. If an item cannot be retrieved, either because the timeout expires, cancellation is requested, or the source is empty and completed, the returned task will be canceled. The is null (Nothing in Visual Basic). timeout is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than .

Synchronously receives an item from the source.

Specifies the type of data contained in the source. The source from which to receive. The received item. The is null (Nothing in Visual Basic). No item could be received from the source.

Synchronously receives an item from the source.

Specifies the type of data contained in the source. The source from which to receive. The which may be used to cancel the receive operation. The received item. The is null (Nothing in Visual Basic). No item could be received from the source. The operation was canceled before an item was received from the source. If the source successfully offered an item that was received by this operation, it will be returned, even if a concurrent cancellation request occurs.

Synchronously receives an item from the source.

Specifies the type of data contained in the source. The source from which to receive. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. The received item. timeout is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . The is null (Nothing in Visual Basic). No item could be received from the source. The specified timeout expired before an item was received from the source. If the source successfully offered an item that was received by this operation, it will be returned, even if a concurrent timeout occurs.

Synchronously receives an item from the source.

Specifies the type of data contained in the source. The source from which to receive. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. The which may be used to cancel the receive operation. The received item. The is null (Nothing in Visual Basic). timeout is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . No item could be received from the source. The specified timeout expired before an item was received from the source. The operation was canceled before an item was received from the source. If the source successfully offered an item that was received by this operation, it will be returned, even if a concurrent timeout or cancellation request occurs.

Receives an item from the source.

Specifies the type of data contained in the source. The source from which to receive. Whether to first attempt using TryReceive to get a value from the source. A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. The which may be used to cancel the receive operation. A Task for the receive operation.

The reason for a ReceiveCoreByLinking call failing.

The Receive operation completed successfully, obtaining a value from the source.

The timer expired before a value could be received.

The cancellation token had cancellation requested before a value could be received.

The source completed before a value could be received.

An error occurred while linking up the target.

An error during cleanup after completion for another reason.

Cancels a CancellationTokenSource passed as the object state argument.

Receives an item from the source by linking a temporary target from it.

Specifies the type of data contained in the source. The source from which to receive. The number of milliseconds to wait, or -1 to wait indefinitely. The which may be used to cancel the receive operation.

Provides a TaskCompletionSource that is also a dataflow target for use in ReceiveCore.

Specifies the type of data offered to the target.

Cached delegate used in ReceiveCoreByLinking on the created timer. Passed the ReceiveTarget as the argument.

The C# compiler will not cache this delegate by default due to it being a generic method on a non-generic class.

Cached delegate used in ReceiveCoreByLinking on the cancellation token. Passed the ReceiveTarget as the state argument.

The C# compiler will not cache this delegate by default due to it being a generic method on a non-generic class.

The received value if we accepted a value from the source.

The cancellation token source representing both external and internal cancellation.

Indicates a code path is already on route to complete the target. 0 is false, 1 is true.

The external token that cancels the internal token.

The registration on the external token that cancels the internal token.

The timer that fires when the timeout has been exceeded.

The unlinker from removing this target from the source from which we're receiving.

The received exception if an error occurred.

Gets the sync obj used to synchronize all activity on this target.

Initializes the target.

Offers a message to be used to complete the TaskCompletionSource.

Attempts to reserve the right to cleanup and complete, and if successfully, continues to cleanup and complete.

The reason we're completing and cleaning up. true if successful in completing; otherwise, false.

Cleans up the target for completion.

The reason we're completing and cleaning up. This method must only be called once on this instance.

Creates an exception to use when a source completed before receiving a value.

The initialized exception.

Creates an exception to use when a timeout occurs before receiving a value.

The initialized exception.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a that asynchronously monitors the source for available output.

Specifies the type of data contained in the source. The source to monitor. A that informs of whether and when more output is available. When the task completes, if its is true, more output is available in the source (though another consumer of the source may retrieve the data). If it returns false, more output is not and will never be available, due to the source completing prior to output being available.

Provides a that asynchronously monitors the source for available output.

Specifies the type of data contained in the source. The source to monitor. The cancellation token with which to cancel the asynchronous operation. A that informs of whether and when more output is available. When the task completes, if its is true, more output is available in the source (though another consumer of the source may retrieve the data). If it returns false, more output is not and will never be available, due to the source completing prior to output being available.

Provides a target used in OutputAvailableAsync operations.

Specifies the type of data in the data source being checked.

Cached continuation delegate that unregisters from cancellation and marshals the antecedent's result to the return value.

Cached delegate that cancels the target and unlinks the target from the source. Expects an OutputAvailableAsyncTarget as the state argument.

Cancels the target and unlinks the target from the source.

An OutputAvailableAsyncTarget.

Disposes of _unlinker if the target has been linked.

The IDisposable used to unlink this target from its source.

The registration used to unregister this target from the cancellation token.

Completes the task when offered a message (but doesn't consume the message).

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Encapsulates a target and a source into a single propagator.

Specifies the type of input expected by the target. Specifies the type of output produced by the source. The target to encapsulate. The source to encapsulate. The encapsulated target and source. This method does not in any way connect the target to the source. It creates a propagator block whose target methods delegate to the specified target and whose source methods delegate to the specified source. Any connection between the target and the source is left for the developer to explicitly provide. The propagator's implementation delegates to the specified source.

Provides a dataflow block that encapsulates a target and a source to form a single propagator.

The target half.

The source half.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

The predicate a value must successfully pass in order for it to be received. may be null (Nothing in Visual Basic), in which case all items will pass. The item received from the source.true if an item could be received; otherwise, false. This method does not block waiting for the source to provide an item. It will return after checking for an element, whether or not an element was available.

Attempts to synchronously receive all available items from the .

The items received from the source.true if one or more items could be received; otherwise, false. This method does not block waiting for the source to provide an item. It will return after checking for elements, whether or not an element was available.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

A debug view for the propagator.

The propagator being debugged.

Initializes the debug view.

The propagator being debugged.

The target.

The source.

Monitors two dataflow sources, invoking the provided handler for whichever source makes data available first.

Specifies type of data contained in the first source. Specifies type of data contained in the second source. The first source. The handler to execute on data from the first source. The second source. The handler to execute on data from the second source. A that represents the asynchronous choice. If both sources are completed prior to the choice completing, the resulting task will be canceled. When one of the sources has data available and successfully propagates it to the choice, the resulting task will complete when the handler completes: if the handler throws an exception, the task will end in the state containing the unhandled exception, otherwise the task will end with its set to either 0 or 1 to represent the first or second source, respectively. This method will only consume an element from one of the two data sources, never both. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Monitors two dataflow sources, invoking the provided handler for whichever source makes data available first.

Specifies type of data contained in the first source. Specifies type of data contained in the second source. The first source. The handler to execute on data from the first source. The second source. The handler to execute on data from the second source. The options with which to configure this choice. A that represents the asynchronous choice. If both sources are completed prior to the choice completing, or if the CancellationToken provided as part of is canceled prior to the choice completing, the resulting task will be canceled. When one of the sources has data available and successfully propagates it to the choice, the resulting task will complete when the handler completes: if the handler throws an exception, the task will end in the state containing the unhandled exception, otherwise the task will end with its set to either 0 or 1 to represent the first or second source, respectively. This method will only consume an element from one of the two data sources, never both. If cancellation is requested after an element has been received, the cancellation request will be ignored, and the relevant handler will be allowed to execute. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Monitors three dataflow sources, invoking the provided handler for whichever source makes data available first.

Specifies type of data contained in the first source. Specifies type of data contained in the second source. Specifies type of data contained in the third source. The first source. The handler to execute on data from the first source. The second source. The handler to execute on data from the second source. The third source. The handler to execute on data from the third source. A that represents the asynchronous choice. If all sources are completed prior to the choice completing, the resulting task will be canceled. When one of the sources has data available and successfully propagates it to the choice, the resulting task will complete when the handler completes: if the handler throws an exception, the task will end in the state containing the unhandled exception, otherwise the task will end with its set to the 0-based index of the source. This method will only consume an element from one of the data sources, never more than one. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Monitors three dataflow sources, invoking the provided handler for whichever source makes data available first.

Specifies type of data contained in the first source. Specifies type of data contained in the second source. Specifies type of data contained in the third source. The first source. The handler to execute on data from the first source. The second source. The handler to execute on data from the second source. The third source. The handler to execute on data from the third source. The options with which to configure this choice. A that represents the asynchronous choice. If all sources are completed prior to the choice completing, or if the CancellationToken provided as part of is canceled prior to the choice completing, the resulting task will be canceled. When one of the sources has data available and successfully propagates it to the choice, the resulting task will complete when the handler completes: if the handler throws an exception, the task will end in the state containing the unhandled exception, otherwise the task will end with its set to the 0-based index of the source. This method will only consume an element from one of the data sources, never more than one. If cancellation is requested after an element has been received, the cancellation request will be ignored, and the relevant handler will be allowed to execute. The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Monitors dataflow sources, invoking the provided handler for whichever source makes data available first.

Tries to remove data from a receivable source and schedule an action to process that received item.

Specifies the type of data to process. The source from which to receive the data. The action to run for the received data. The branch ID associated with this source/action pair. The scheduler to use to process the action. The task created for processing the received item. true if this try attempt satisfies the choose operation; otherwise, false.

Monitors dataflow sources, invoking the provided handler for whichever source makes data available first.

Creates a target for a branch of a Choose.

Specifies the type of data coming through this branch. A strong box around the completed Task from any target. Also sync obj for access to the targets. The CancellationTokenSource used to issue tear down / cancellation requests. The TaskScheduler on which to scheduler work. The ID of this branch, used to complete the resultTask. The source with which this branch is associated. The action to run for a single element received from the source. A task representing the branch.

Provides a dataflow target used by Choose to receive data from a single source.

Specifies the type of data offered to this target.

Delegate used to invoke the action for a branch when that branch is activated on the fast path.

A wrapper for the task that represents the completed branch of this choice. The wrapper is also the sync object used to protect all choice branch's access to shared state.

Initializes the target.

The completed wrapper shared between all choice branches. The cancellation token used to cancel this target.

Called when this choice branch is being offered a message.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Creates a new abstraction over the .

Specifies the type of data contained in the source. The source to wrap. An IObservable{TOutput} that enables observers to be subscribed to the source. The is null (Nothing in Visual Basic).

Cached options for non-greedy processing.

Provides an IObservable veneer over a source block.

The table that maps source to cached observable.

ConditionalWeakTable doesn't do the initialization under a lock, just the publication. This means that if there's a race to create two observables off the same source, we could end up instantiating multiple SourceObservable instances, of which only one will be published. Worst case, we end up with a few additional continuations off of the source's completion task.

Gets an observable to represent the source block.

The source. The observable.

Object used to synchronize all subscriptions, unsubscriptions, and propagations.

The wrapped source.

The current target. We use the same target until the number of subscribers drops to 0, at which point we substitute in a new target.

Initializes the SourceObservable.

The source to wrap.

Gets any exceptions from the source block.

The aggregate exception of all errors, or null if everything completed successfully.

Subscribes the observer to the source.

the observer to subscribe. An IDisposable that may be used to unsubscribe the source.

Unsubscribes the observer.

The observer being unsubscribed.

Resets the observer state to the original, inactive state.

The list of active observers prior to the reset.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the observable.

The observable being debugged.

Initializes the debug view.

The target being debugged.

Gets an enumerable of the observers.

State associated with the current target for propagating data to observers.

The owning SourceObservable.

The ActionBlock that consumes data from a source and offers it to targets.

Used to cancel continuations when they're no longer necessary.

A list of the observers currently registered with this target. The list is immutable to enable iteration through the list while the set of observers may be changing.

Used to unlink the source from this target when the last observer is unsubscribed.

Temporary list to keep track of SendAsync tasks to TargetObservers with back pressure. This field gets instantiated on demand. It gets populated and cleared within an offering cycle.

Initializes the target instance.

The owning observable.

Forwards an item to all currently subscribed observers.

The item to forward.

Notifies all currently registered observers that they should complete.

Non-null when an unexpected exception occurs during processing. Faults all subscribed observers and resets the observable back to its original condition.

Creates a new abstraction over the .

Specifies the type of input accepted by the target block. The target to wrap. An observer that wraps the target block.

Provides an observer wrapper for a target block.

The wrapped target.

Initializes the observer.

The target to wrap.

Sends the value to the observer.

The value to send.

Completes the target.

Forwards the error to the target.

The exception to forward.

Sends a value to the underlying target asynchronously.

The value to send. A Task{bool} to wait on.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Gets a target block that synchronously accepts all messages offered to it and drops them.

The type of the messages this block can accept. A that accepts and subsequently drops all offered messages.

Target block that synchronously accepts all messages offered to it and drops them.

The type of the messages this block can accept.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Provides options used to configure the processing performed by dataflow blocks.

is mutable and can be configured through its properties. When specific configuration options are not set, the following defaults are used: Options Default TaskScheduler MaxMessagesPerTask DataflowBlockOptions.Unbounded (-1) CancellationToken BoundedCapacity DataflowBlockOptions.Unbounded (-1) NameFormat "{0} Id={1}" EnsureOrdered true Dataflow blocks capture the state of the options at their construction. Subsequent changes to the provided instance should not affect the behavior of a dataflow block.

A constant used to specify an unlimited quantity for members that provide an upper bound. This field is constant.

The scheduler to use for scheduling tasks to process messages.

The cancellation token to monitor for cancellation requests.

The maximum number of messages that may be processed per task.

The maximum number of messages that may be buffered by the block.

The name format to use for creating a name for a block.

Whether to force ordered processing of messages.

A default instance of .

Do not change the values of this instance. It is shared by all of our blocks when no options are provided by the user.

Returns this instance if it's the default instance or else a cloned instance.

An instance of the options that may be cached by the block.

Initializes the .

Gets or sets the to use for scheduling tasks.

Gets or sets the to monitor for cancellation requests.

Gets or sets the maximum number of messages that may be processed per task.

Gets a MaxMessagesPerTask value that may be used for comparison purposes.

The maximum value, usable for comparison purposes. Unlike MaxMessagesPerTask, this property will always return a positive value.

Gets or sets the maximum number of messages that may be buffered by the block.

Gets or sets the format string to use when a block is queried for its name.

The name format may contain up to two format items. {0} will be substituted with the block's name. {1} will be substituted with the block's Id, as is returned from the block's Completion.Id property.

Gets or sets whether ordered processing should be enforced on a block's handling of messages.

By default, dataflow blocks enforce ordering on the processing of messages. This means that a block like will ensure that messages are output in the same order they were input, even if parallelism is employed by the block and the processing of a message N finishes after the processing of a subsequent message N+1 (the block will reorder the results to maintain the input ordering prior to making those results available to a consumer). Some blocks may allow this to be relaxed, however. Setting to false tells a block that it may relax this ordering if it's able to do so. This can be beneficial if the immediacy of a processed result being made available is more important than the input-to-output ordering being maintained.

Provides options used to configure the processing performed by dataflow blocks that process each message through the invocation of a user-provided delegate, blocks such as and .

is mutable and can be configured through its properties. When specific configuration options are not set, the following defaults are used: Options Default TaskScheduler CancellationToken MaxMessagesPerTask DataflowBlockOptions.Unbounded (-1) BoundedCapacity DataflowBlockOptions.Unbounded (-1) NameFormat "{0} Id={1}" EnsureOrdered true MaxDegreeOfParallelism 1 SingleProducerConstrained false Dataflow block captures the state of the options at their construction. Subsequent changes to the provided instance should not affect the behavior of a dataflow block.

A default instance of .

Do not change the values of this instance. It is shared by all of our blocks when no options are provided by the user.

Returns this instance if it's the default instance or else a cloned instance.

An instance of the options that may be cached by the block.

The maximum number of tasks that may be used concurrently to process messages.

Whether the code using this block will only ever have a single producer accessing the block at any given time.

Initializes the .

Gets the maximum number of messages that may be processed by the block concurrently.

Gets whether code using the dataflow block is constrained to one producer at a time.

This property defaults to false, such that the block may be used by multiple producers concurrently. This property should only be set to true if the code using the block can guarantee that it will only ever be used by one producer (e.g. a source linked to the block) at a time, meaning that methods like Post, Complete, Fault, and OfferMessage will never be called concurrently. Some blocks may choose to capitalize on the knowledge that there will only be one producer at a time in order to provide better performance.

Gets a MaxDegreeOfParallelism value that may be used for comparison purposes.

The maximum value, usable for comparison purposes. Unlike MaxDegreeOfParallelism, this property will always return a positive value.

Gets whether these dataflow block options allow for parallel execution.

Provides options used to configure the processing performed by dataflow blocks that group together multiple messages, blocks such as and .

is mutable and can be configured through its properties. When specific configuration options are not set, the following defaults are used: Options Default TaskScheduler CancellationToken MaxMessagesPerTask DataflowBlockOptions.Unbounded (-1) BoundedCapacity DataflowBlockOptions.Unbounded (-1) NameFormat "{0} Id={1}" EnsureOrdered true MaxNumberOfGroups GroupingDataflowBlockOptions.Unbounded (-1) Greedy true Dataflow block capture the state of the options at their construction. Subsequent changes to the provided instance should not affect the behavior of a dataflow block.

A default instance of .

Do not change the values of this instance. It is shared by all of our blocks when no options are provided by the user.

Returns this instance if it's the default instance or else a cloned instance.

An instance of the options that may be cached by the block.

Whether the block should greedily consume offered messages.

The maximum number of groups that should be generated by the block.

Initializes the .

Gets or sets the Boolean value to use to determine whether to greedily consume offered messages.

Gets or sets the maximum number of groups that should be generated by the block.

Gets a MaxNumberOfGroups value that may be used for comparison purposes.

The maximum value, usable for comparison purposes. Unlike MaxNumberOfGroups, this property will always return a positive value.

Provides options used to configure a link between dataflow blocks.

is mutable and can be configured through its properties. When specific configuration options are not set, the following defaults are used: Options Default PropagateCompletion False MaxMessages DataflowBlockOptions.Unbounded (-1) Append True Dataflow blocks capture the state of the options at linking. Subsequent changes to the provided instance should not affect the behavior of a link.

A constant used to specify an unlimited quantity for members that provide an upper bound. This field is a constant tied to .

Whether the linked target will have completion and faulting notification propagated to it automatically.

The maximum number of messages that may be consumed across the link.

Whether the link should be appended to the source?s list of links, or whether it should be prepended.

A default instance of .

Do not change the values of this instance. It is shared by all of our blocks when no options are provided by the user.

A cached instance of .

Do not change the values of this instance. It is shared by all of our blocks that need to unlink after one message has been consumed.

Initializes the .

Gets or sets whether the linked target will have completion and faulting notification propagated to it automatically.

Gets or sets the maximum number of messages that may be consumed across the link.

Gets or sets whether the link should be appended to the source?s list of links, or whether it should be prepended.

Provides a container of data attributes for passing between dataflow blocks.

The message ID. Needs to be unique within the source.

Initializes the with the specified attributes.

The ID of the message. Must be unique within the originating source block. Need not be globally unique.

Gets the validity of the message.

True if the ID of the message is different from 0. False if the ID of the message is 0

Gets the ID of the message within the source.

The ID contained in the instance.

Checks two instances for equality by ID without boxing.

Another instance. True if the instances are equal. False otherwise.

Checks boxed instances for equality by ID.

A boxed instance. True if the instances are equal. False otherwise.

Generates a hash code for the instance.

Hash code.

Checks two instances for equality by ID.

A instance. A instance. True if the instances are equal. False otherwise.

Checks two instances for non-equality by ID.

A instance. A instance. True if the instances are not equal. False otherwise.

Represents the status of a when passed between dataflow blocks.

Indicates that the accepted the message. Once a target has accepted a message, it is wholly owned by the target.

Indicates that the declined the message. The still owns the message.

Indicates that the postponed the message for potential consumption at a later time. The still owns the message.

Indicates that the tried to accept the message from the , but the message was no longer available.

Indicates that the declined the message. The still owns the message. Additionally, the will decline all future messages sent by the source.

Represents a dataflow block.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Represents a dataflow block that is both a target for data and a source of data.

Specifies the type of data accepted by the . Specifies the type of data supplied by the .

Represents a dataflow block that supports receiving of messages without linking.

Specifies the type of data supplied by the .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Represents a dataflow block that is a source of data.

Specifies the type of data supplied by the .

Links the to the specified .

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Represents a dataflow block that is a target for data.

Specifies the type of data accepted by the .

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Provides a dataflow block that invokes a provided delegate for every data element received.

Specifies the type of data operated on by this .

The core implementation of this message block when in default mode.

The core implementation of this message block when in SPSC mode.

Initializes the with the specified .

The action to invoke with each data element received. The is null (Nothing in Visual Basic).

Initializes the with the specified and .

The action to invoke with each data element received. The options with which to configure this . The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Initializes the with the specified .

The action to invoke with each data element received. The is null (Nothing in Visual Basic).

Initializes the with the specified and .

The action to invoke with each data element received. The options with which to configure this . The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Initializes the with the specified delegate and options.

The action to invoke with each data element received. The options with which to configure this . The is null (Nothing in Visual Basic). The is null (Nothing in Visual Basic).

Processes the message with a user-provided action.

The action to use to process the message. The message to be processed.

Processes the message with a user-provided action that returns a task.

The action to use to process the message. The message to be processed.

Completes the processing of an asynchronous message.

The completed task.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Posts an item to the .

The item being offered to the target. true if the item was accepted by the target block; otherwise, false. This method will return once the target block has decided to accept or decline the item, but unless otherwise dictated by special semantics of the target block, it does not wait for the item to actually be processed (for example, will return from Post as soon as it has stored the posted item into its input queue). From the perspective of the block's processing, Post is asynchronous. For target blocks that support postponing offered messages, or for blocks that may do more processing in their Post implementation, consider using SendAsync, which will return immediately and will enable the target to postpone the posted message and later consume it after SendAsync returns.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Gets the number of input items waiting to be processed by this block.

The InputCount does not include any items currently being processed by the block or any items that have already been processed by the block.

Gets the number of messages waiting to be processed. This must only be used from the debugger.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Call.

The action block being viewed.

The action block's default target being viewed.

The action block's SPSC target being viewed.

Initializes the debug view.

The target being debugged.

Gets the messages waiting to be processed.

Gets any postponed messages.

Gets the number of outstanding input operations.

Gets the ExecutionDataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the block's Id.

Provides a dataflow block that batches inputs into arrays.

Specifies the type of data put into batches.

The target half of this batch.

The source half of this batch.

Initializes this with the specified batch size.

The number of items to group into a batch. The must be positive.

Initializes this with the specified batch size, declining option, and block options.

The number of items to group into a batch. The options with which to configure this . The must be positive. The must be no greater than the value of the BoundedCapacity option if a non-default value has been set. The is null (Nothing in Visual Basic).

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Triggers the to initiate a batching operation even if the number of currently queued or postponed items is less than the .

In greedy mode, a batch will be generated from queued items even if fewer exist than the batch size. In non-greedy mode, a batch will be generated asynchronously from postponed items even if fewer than the batch size can be consumed.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of output items available to be received from this block.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Gets the size of the batches generated by this .

If the number of items provided to the block is not evenly divisible by the batch size provided to the block's constructor, the block's final batch may contain fewer than the requested number of items.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets the number of messages waiting to be offered. This must only be used from the debugger as it avoids taking necessary locks.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Batch.

The batch block being viewed.

The target half being viewed.

The source half of the block being viewed.

Initializes the debug view.

The batch being viewed.

Gets the messages waiting to be processed.

Gets the messages waiting to be received.

Gets the number of batches that have been completed.

Gets the task being used for input processing.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets the size of batches generated by the block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the block's Id.

Gets the messages postponed by this batch.

Gets the set of all targets linked from this block.

Provides the core target implementation for a Batch.

The messages in this target.

A task representing the completion of the block.

Gets the object used as the incoming lock.

The target that owns this target core.

The batch size.

State used when in non-greedy mode.

Bounding state for when the block is executing in bounded mode.

The options associated with this block.

The action invoked with a completed batch.

Whether to stop accepting new messages.

Whether we've completed at least one batch.

Whether someone has reserved the right to call CompleteBlockOncePossible.

State used only when in non-greedy mode.

Collection of postponed messages.

A temporary array used to store data retrieved from PostponedMessages.

A temporary list used in non-greedy mode when consuming postponed messages to store successfully reserved messages.

Whether the next batching operation should accept fewer than BatchSize items.

This value may be read not under a lock, but it must only be written to protected by the IncomingLock.

The task used to process messages.

Initializes the NonGreedyState.

The batch size used by the BatchBlock.

Initializes this target core with the specified configuration.

The owning batch target. The number of items to group into a batch. The delegate to invoke when a batch is completed. The options with which to configure this . Assumed to be immutable. The must be positive. The is null (Nothing in Visual Basic).

Triggers a batching operation even if the number of currently queued or postponed items is less than the .

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Completes/faults the block. In general, it is not safe to pass releaseReservedMessages:true, because releasing of reserved messages is done without taking a lock. We pass releaseReservedMessages:true only when an exception has been caught inside the message processing loop which is a single instance at any given moment.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Gets the size of the batches generated by this .

Gets whether the target has had cancellation requested or an exception has occurred.

Returns the available capacity to bring in postponed items. The exact values above _batchSize don't matter.

Completes the block once all completion conditions are met.

Gets whether we should launch further synchronous or asynchronous processing to create batches.

Called when new messages are available to be processed.

Whether this call is the continuation of a previous message loop.

Slow path for ProcessAsyncIfNecessary. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Task body used to process messages.

Create a batch from the available items.

Whether to make a batch even if there are fewer than BatchSize items available. true if a batch was created and published; otherwise, false.

Retrieves postponed items in non-greedy mode if we have enough to make a batch.

Whether we'll accept consuming fewer elements than the defined batch size.

Retrieves postponed items in greedy bounded mode.

Whether we'll accept consuming fewer elements than the defined batch size.

Consumes all of the reserved messages stored in the non-greedy state's temporary reserved source list.

Releases all of the reserved messages stored in the non-greedy state's temporary reserved source list.

Whether to allow an exception from a release to propagate immediately, or to delay propagation until all releases have been attempted.

Notifies the block that one or more items was removed from the queue.

The number of items removed.

Counts the input items in a single output item or in a list of output items.

A single output item. Only considered if multipleOutputItems == null. A list of output items. May be null.

Gets the number of messages waiting to be processed. This must only be used from the debugger as it avoids taking necessary locks.

Gets information about this helper to be used for display in a debugger.

Debugging information about this target.

Gets the object to display in the debugger display attribute.

Provides a wrapper for commonly needed debugging information.

The target being viewed.

Initializes the debugging helper.

The target being viewed.

Gets the messages waiting to be processed.

Gets the task being used for input processing.

Gets the collection of postponed messages.

Gets whether the block is declining further messages.

Gets the DataflowBlockOptions used to configure this block.

Gets the number of batches that have been completed.

Provides a dataflow block that batches a specified number of inputs of potentially differing types provided to one or more of its targets.

Specifies the type of data accepted by the block's first target. Specifies the type of data accepted by the block's second target.

The size of the batches generated by this BatchedJoin.

State shared among the targets.

The target providing inputs of type T1.

The target providing inputs of type T2.

The source side.

Initializes this with the specified configuration.

The number of items to group into a batch. The must be positive.

Initializes this with the specified configuration.

The number of items to group into a batch. The options with which to configure this . The must be positive. The is null (Nothing in Visual Basic).

Gets the size of the batches generated by this .

Gets a target that may be used to offer messages of the first type.

Gets a target that may be used to offer messages of the second type.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of output items available to be received from this block.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Invokes Complete on each target

Gets the number of messages waiting to be processed. This must only be used from the debugger as it avoids taking necessary locks.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Transform.

The block being viewed.

The source half of the block being viewed.

Initializes the debug view.

The batched join being viewed.

Gets the messages waiting to be received.

Gets the number of batches created.

Gets the number of items remaining to form a batch.

Gets the size of the batches generated by this BatchedJoin.

Gets the first target.

Gets the second target.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is completed.

Gets the block's Id.

Gets the set of all targets linked from this block.

Gets the target that holds a reservation on the next message, if any.

Provides a dataflow block that batches a specified number of inputs of potentially differing types provided to one or more of its targets.

Specifies the type of data accepted by the block's first target. Specifies the type of data accepted by the block's second target. Specifies the type of data accepted by the block's third target.

The size of the batches generated by this BatchedJoin.

State shared among the targets.

The target providing inputs of type T1.

The target providing inputs of type T2.

The target providing inputs of type T3.

The source side.

Initializes this with the specified configuration.

The number of items to group into a batch. The must be positive.

Initializes this with the specified configuration.

The number of items to group into a batch. The options with which to configure this . The must be positive. The is null (Nothing in Visual Basic).

Gets the size of the batches generated by this .

Gets a target that may be used to offer messages of the first type.

Gets a target that may be used to offer messages of the second type.

Gets a target that may be used to offer messages of the third type.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of output items available to be received from this block.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Invokes Complete on each target

Gets the number of messages waiting to be processed. This must only be used from the debugger as it avoids taking necessary locks.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Transform.

The block being viewed.

The source half of the block being viewed.

Initializes the debug view.

The batched join being viewed.

Gets the messages waiting to be received.

Gets the number of batches created.

Gets the number of items remaining to form a batch.

Gets the size of the batches generated by this BatchedJoin.

Gets the first target.

Gets the second target.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is completed.

Gets the block's Id.

Gets the set of all targets linked from this block.

Gets the target that holds a reservation on the next message, if any.

Provides the target used in a BatchedJoin.

Specifies the type of data accepted by this target.

The shared resources used by all targets associated with the same batched join instance.

Whether this target is declining future messages.

Input messages for the next batch.

Initializes the target.

The shared resources used by all targets associated with this batched join.

Gets the number of messages buffered in this target.

Gets the messages buffered by this target and then empties the collection.

The messages from the target.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Transform.

The batched join block target being viewed.

Initializes the debug view.

The batched join target being viewed.

Gets the messages waiting to be processed.

Gets whether the block is declining further messages.

Provides a container for resources shared across all targets used by the same BatchedJoinBlock instance.

Initializes the shared resources.

The size of a batch to create. The options used to configure the shared resources. Assumed to be immutable. The action to invoke when a batch is completed. The action to invoke when no more targets are accepting input. The action to invoke when an exception needs to be logged. The action to invoke when completing, typically invoked due to a call to Fault.

A lock used to synchronize all incoming messages on all targets. It protects all of the rest of the shared Resources's state and will be held while invoking the delegates.

The size of the batches to generate.

The action to invoke when enough elements have been accumulated to make a batch.

The action to invoke when all targets are declining further messages.

The action to invoke when an exception has to be logged.

The action to invoke when the owning block has to be completed.

The number of items remaining to form a batch.

The number of targets still alive (i.e. not declining all further messages).

Whether all targets should decline all further messages.

The number of batches created.

Provides the target used in a Join.

Specifies the type of data accepted by this target.

The shared resources used by all targets associated with the same join instance.

A task representing the completion of the block.

Input messages for the next batch.

State used when in non-greedy mode.

Whether this target is declining future messages.

State used only when in non-greedy mode.

Collection of the last postponed message per source.

The currently reserved message.

The currently consumed message.

Initializes the target.

The shared resources used by all targets associated with this join.

Gets a message buffered by this target.

This must be called while holding the shared Resources's incoming lock.

Gets whether the target is declining messages.

Gets whether the target has at least one message available.

Gets whether the target has at least one postponed message.

Gets the number of messages available or postponed.

Gets whether this target has the highest number of available/buffered messages. This is only valid in greedy mode.

Reserves one of the postponed messages.

true if a message was reserved; otherwise, false.

Consumes a reserved message.

true if a message was consumed; otherwise, false.

Consumes up to one postponed message in greedy bounded mode.

Start declining if the number of joins we've already made plus the number we can make from data already enqueued meets our quota.

Releases the reservation on a reserved message.

Unconditionally clears a reserved message.

Completes the target.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Causes the to complete in a state.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

The completion task on Join targets is only hidden from the public. It still exists for internal purposes.

Gets the number of messages waiting to be processed. This must only be used from the debugger as it avoids taking necessary locks.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the Transform.

The join block target being viewed.

Initializes the debug view.

The join being viewed.

Gets the messages waiting to be processed.

Gets whether the block is declining further messages.

Provides a non-generic base type for all join targets.

Whether the target is postponing messages.

Whether the target has at least one message available.

Whether the target has at least one message postponed.

Gets the number of messages available or postponed.

Gets whether the target has the highest number of messages available. (A tie yields true.)

Reserves a single message.

Whether a message was reserved.

Consumes any previously reserved message.

Whether a message was consumed.

Consumes up to one postponed message in greedy bounded mode.

Whether a message was consumed.

Releases any previously reserved message.

Unconditionally clears a reserved message. This is only invoked in case of an exception.

Access point to the corresponding API method.

Internal implementation of the corresponding API method.

Completes the target.

Provides a container for resources shared across all targets used by the same BatchedJoin instance.

Initializes the shared resources.

The join block that owns these shared resources. The array of targets associated with the join. Also doubles as the sync object used to synchronize targets. The delegate to invoke when enough messages have been consumed to fulfill the join. The delegate to invoke when a target encounters an error. The options for the join.

All of the targets associated with the join.

The delegate to invoke when a target encounters an error.

The delegate to invoke when enough messages have been consumed to fulfill the join.

The options for the join.

Bounding state for when the block is executing in bounded mode.

Whether all targets should decline all further messages.

The task used to process messages.

Whether any exceptions have been generated and stored into the source core.

The number of joins this block has created.

A task has reserved the right to run the completion routine.

Gets the lock used to synchronize all incoming messages on all targets.

Invokes Complete on each target with dropping buffered messages.

Gets whether all of the targets have at least one message in their queues.

Gets whether all of the targets have at least one message in their queues or have at least one postponed message.

Retrieves postponed items if we have enough to make a batch.

true if input messages for a batch were consumed (all or none); false otherwise.

Retrieves up to one postponed item through each target.

true if at least one input message was consumed (through any target); false otherwise.

Gets whether the target has had cancellation requested or an exception has occurred.

Gets whether the join is in a state where processing can be done, meaning there's data to be processed and the block is in a state where such processing is allowed.

Called when new messages are available to be processed.

Whether this call is the continuation of a previous message loop.

Slow path for ProcessAsyncIfNecessary. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Completes the join block if possible.

Task body used to process messages.

Notifies the block that one or more items was removed from the queue.

The number of items removed.

Gets the object to display in the debugger display attribute.

Provider of disposables that run actions.

An IDisposable that does nothing.

Creates an IDisposable that runs an action when disposed.

Specifies the type of the first argument. Specifies the type of the second argument. The action to invoke. The first argument. The second argument. The created disposable.

Creates an IDisposable that runs an action when disposed.

Specifies the type of the first argument. Specifies the type of the second argument. Specifies the type of the third argument. The action to invoke. The first argument. The second argument. The third argument. The created disposable.

A disposable that's a nop.

An IDisposable that will run a delegate when disposed.

First state argument.

Second state argument.

The action to run when disposed. Null if disposed.

Initializes the ActionOnDispose.

The action to run when disposed. The first argument. The second argument.

Gets whether the IDisposable has been disposed.

Invoke the action.

An IDisposable that will run a delegate when disposed.

First state argument.

Second state argument.

Third state argument.

The action to run when disposed. Null if disposed.

Initializes the ActionOnDispose.

The action to run when disposed. The first argument. The second argument. The third argument.

Gets whether the IDisposable has been disposed.

Invoke the action.

Internal helper utilities.

An invalid ID to assign for reordering purposes. This value is chosen to be the last of the 64-bit integers that could ever be assigned as a reordering ID.

A well-known message ID for code that will send exactly one message or where the exact message ID is not important.

A perf optimization for caching a well-known message header instead of constructing one every time it is needed.

The cached completed Task{bool} with a result of true.

The cached completed Task{bool} with a result of false.

The cached completed TaskCompletionSource{VoidResult}.

Asserts that a given synchronization object is either held or not held.

The monitor to check. Whether we want to assert that it's currently held or not held.

Keeping alive processing tasks: maximum number of processed messages.

Keeping alive processing tasks: do not attempt this many times.

A predicate type for TryKeepAliveUntil.

Input state for the predicate in order to avoid closure allocations. Output state for the predicate in order to avoid closure allocations. The state of the predicate.

Actively waits for a predicate to become true.

The predicate to become true. Input state for the predicate in order to avoid closure allocations. Output state for the predicate in order to avoid closure allocations. True if the predicate was evaluated and it returned true. False otherwise.

Unwraps an instance T from object state that is a WeakReference to that instance.

The type of the data to be unwrapped. The weak reference. The T instance.

Gets an ID for the dataflow block.

The dataflow block. An ID for the dataflow block.

Gets the name for the specified block, suitable to be rendered in a debugger window.

The block for which a name is needed. The options to use when rendering the name. If no options are provided, the block's name is used directly. The name of the object. This is used from DebuggerDisplay attributes.

Gets whether the exception represents a cooperative cancellation acknowledgment.

The exception to check. true if this exception represents a cooperative cancellation acknowledgment; otherwise, false.

Registers a block for cancellation by completing when cancellation is requested.

The block's cancellation token. The task that will complete when the block is completely done processing. An action that will decline permanently on the state passed to it. The block on which to decline permanently.

Initializes the stack trace and watson bucket of an inactive exception.

The exception to initialize. The initialized exception.

The name of the key in an Exception's Data collection used to store information on a dataflow message.

Stores details on a dataflow message into an Exception's Data collection.

Specifies the type of data stored in the message. The Exception whose Data collection should store message information. The message information to be stored. Whether to store the data into the exception's inner exception(s) in addition to the exception itself.

Stores the specified string value into the specified key slot of the specified exception's data dictionary.

The exception into which the key/value should be stored. The key. The value to be serialized as a string and stored. If the key is already present in the exception's data dictionary, the value is not overwritten.

Throws an exception asynchronously on the thread pool.

The exception to throw. This function is used when an exception needs to be propagated from a thread other than the current context. This could happen, for example, if the exception should cause the standard CLR exception escalation behavior, but we're inside of a task that will squirrel the exception away.

Adds the exception to the list, first initializing the list if the list is null.

The list to add the exception to, and initialize if null. The exception to add or whose inner exception(s) should be added. Unwrap and add the inner exception(s) rather than the specified exception directly. This method is not thread-safe, in that it manipulates without any synchronization.

Creates a task we can cache for the desired Boolean result.

The value of the Boolean. A task that may be cached.

Creates a TaskCompletionSource{T} completed with a value of default(T) that we can cache.

Completed TaskCompletionSource{T} that may be cached.

Creates a task faulted with the specified exception.

Specifies the type of the result for this task. The exception with which to complete the task. The faulted task.

Creates a task canceled with the specified cancellation token.

Specifies the type of the result for this task. The canceled task.

Gets the completion task of a block, and protects against common cases of the completion task not being implemented or supported.

The block. The completion task, or null if the block's completion task is not implemented or supported.

Creates an IDisposable that, when disposed, will acquire the outgoing lock while removing the target block from the target registry.

Specifies the type of data in the block. The outgoing lock used to protect the target registry. The target registry from which the target should be removed. The target to remove from the registry. An IDisposable that will unregister the target block from the registry while holding the outgoing lock.

An infinite TimeSpan.

Validates that a timeout either is -1 or is non-negative and within the range of an Int32.

The timeout to validate. true if the timeout is valid; otherwise, false.

Gets the options to use for continuation tasks.

Any options to include in the result. The options to use.

Gets the options to use for tasks.

If this task is being created to replace another. These options should be used for all tasks that have the potential to run user code or that are repeatedly spawned and thus need a modicum of fair treatment. The options to use.

Starts an already constructed task with handling and observing exceptions that may come from the scheduling process.

Task to be started. TaskScheduler to schedule the task on. null on success, an exception reference on scheduling error. In the latter case, the task reference is nulled out.

Starts an already constructed task with handling and observing exceptions that may come from the scheduling process.

Task to be started. TaskScheduler to schedule the task on. null on success, an exception reference on scheduling error. In the latter case, the task reference is nulled out.

Pops and explicitly releases postponed messages after the block is done with processing.

No locks should be held at this time. Unfortunately we cannot assert that.

Cache ThrowAsync to avoid allocations when it is passed into PropagateCompletionXxx.

Propagates completion of sourceCompletionTask to target synchronously.

The task whose completion is to be propagated. It must be completed. The block where completion is propagated. Handler for exceptions from the target. May be null which would propagate the exception to the caller.

Creates a continuation off sourceCompletionTask to complete target. See PropagateCompletion.

Propagates completion of sourceCompletionTask to target based on sourceCompletionTask's current state. See PropagateCompletion.

Static class used to cache generic delegates the C# compiler doesn't cache by default.

Without this, we end up allocating the generic delegate each time the operation is used.

A function that returns the default value of T.

A function to use as the body of ActionOnDispose in CreateUnlinkerShim. Passed a tuple of the sync obj, the target registry, and the target block as the state parameter.

State used only when bounding.

The maximum number of messages allowed to be buffered.

The number of messages currently stored.

This value may temporarily be higher than the actual number stored. That's ok, we just can't accept any new messages if CurrentCount >= BoundedCapacity. Worst case is that we may temporarily have fewer items in the block than our maximum allows, but we'll never have more.

Initializes the BoundingState.

The positive bounded capacity.

Gets whether there's room available to add another message.

Stated used only when bounding and when postponed messages are stored.

Specifies the type of input messages.

Queue of postponed messages.

The number of transfers from the postponement queue to the input queue currently being processed.

Blocks that use TargetCore need to transfer messages from the postponed queue to the input messages queue. While doing that, new incoming messages may arrive, and if they view the postponed queue as being empty (after the block has removed the last postponed message and is consuming it, before storing it into the input queue), they might go directly into the input queue... that will then mess up the ordering between those postponed messages and the newly incoming messages. To address that, OutstandingTransfers is used to track the number of transfers currently in progress. Incoming messages must be postponed not only if there are already any postponed messages, but also if there are any transfers in progress (i.e. this value is > 0). It's an integer because the DOP could be greater than 1, and thus we need to ref count multiple transfers that might be in progress.

Initializes the BoundingState.

The positive bounded capacity.

Gets the number of postponed messages for the debugger.

Stated used only when bounding and when postponed messages and a task are stored.

Specifies the type of input messages.

The task used to process messages.

Initializes the BoundingState.

The positive bounded capacity.

Type used with TaskCompletionSource(Of TResult) as the TResult to ensure that the resulting task can't be upcast to something that in the future could lead to compat problems.

Provides an event source for tracing Dataflow information.

Defines the singleton instance for the dataflow ETW provider. The dataflow provider GUID is {16F53577-E41D-43D4-B47E-C17025BF4025}.

Prevent external instantiation. All logging should go through the Log instance.

Enabled for all keywords.

The event ID for when we encounter a new dataflow block object that hasn't had its name traced to the trace file.

The event ID for the task launched event.

The event ID for the block completed event.

The event ID for the block linked event.

The event ID for the block unlinked event.

Trace an event for when a new block is instantiated.

The dataflow block that was created. The options with which the block was created.

Trace an event for a block launching a task to handle messages.

The owner block launching a task. The task being launched for processing. The reason the task is being launched. The number of messages available to be handled by the task.

Describes the reason a task is being launched.

A task is being launched to process incoming messages.

A task is being launched to offer outgoing messages to linked targets.

Trace an event for a block completing.

The block that's completing.

Describes the reason a block completed.

The block completed successfully.

The block completed due to an error.

The block completed due to cancellation.

Trace an event for a block linking.

The source block linking to a target. The target block being linked from a source.

Trace an event for a block unlinking.

The source block unlinking from a target. The target block being unlinked from a source.

Debugger type proxy for an enumerable of T.

The enumerable being visualized.

Initializes the debug view.

The enumerable being debugged.

Gets the contents of the list.

Debugger type proxy for an enumerable of T.

The enumerable being visualized.

Initializes the debug view.

The enumerable being debugged.

Gets the contents of the list.

Implemented to provide customizable data for debugger displays.

The object to be displayed as the content of a DebuggerDisplayAttribute.

The property returns an object to allow the debugger to interpret arbitrary .NET objects. The return value may be, but need not be limited to be, a string.

Provides a simple, immutable array.

Specifies the type of the data stored in the array.

An empty array.

The immutable data in this array instance.

Gets the empty array.

Initializes the immutable array with the specified elements.

The element array to use for this array's data.

Creates a new immutable array from this array and the additional element.

The item to add. The new array.

Creates a new immutable array from this array and without the specified element.

The item to remove. The new array.

Gets the number of elements in this array.

Gets whether the array contains the specified item.

The item to lookup. true if the array contains the item; otherwise, false.

Returns an enumerator that iterates through the collection.

Returns the contents of the collection as an array.

An array containing the contents of this collection.

A placeholder class for common padding constants and eventually routines.

A size greater than or equal to the size of the most common CPU cache lines.

Padding structure used to minimize false sharing in SingleProducerSingleConsumerQueue{T}.

Value type that contains single Int64 value padded on both sides.

Provides a data structure that supports pushing and popping key/value pairs. Pushing a key/value pair for which the key already exists results in overwriting the existing key entry's value.

Specifies the type of keys in the map. Specifies the type of values in the map. This type is not thread-safe.

A queue structure that uses an array-based list to store its items and that supports overwriting elements at specific indices.

The type of the items storedin the queue This type is not thread-safe.

Terminator index.

The queue where the items will be stored. The key of each entry is the index of the next entry in the queue.

Index of the first queue item.

Index of the last queue item.

Index of the first free slot.

Initializes the Queue instance.

The capacity of the internal storage.

Enqueues an item.

The item to be enqueued. The index of the slot where item was stored.

Tries to dequeue an item.

The item that is dequeued.

Replaces the item of a given slot.

The index of the slot where the value should be replaced. The item to be places.

The queue of elements.

A map from key to index into the list.

The correctness of this map relies on the list only having elements removed from its end.

Initializes the QueuedMap.

The initial capacity of the data structure.

Pushes a key/value pair into the data structure.

The key for the pair. The value for the pair.

Try to pop the next element from the data structure.

The popped pair. true if an item could be popped; otherwise, false.

Tries to pop one or more elements from the data structure.

The items array into which the popped elements should be stored. The offset into the array at which to start storing popped items. The number of items to be popped. The number of items popped, which may be less than the requested number if fewer existed in the data structure.

Gets the number of items in the data structure.

Base interface for reordering buffers.

Informs the reordering buffer not to expect the message with the specified id.

The id of the message to be ignored.

Provides a buffer that reorders items according to their incoming IDs.

Specifies the type of data stored in the items being reordered. This type expects the first item to be ID==0 and for all subsequent items to increase IDs sequentially.

The source that owns this reordering buffer.

A reordering buffer used when parallelism is employed and items may be completed out-of-order.

Also serves as the sync object to protect the contents of this class.

Action used to output items in order.

The ID of the next item that should be released from the reordering buffer.

Gets the object used to synchronize all access to the reordering buffer's internals.

Initializes the reordering buffer.

The source that owns this reordering buffer. The action to invoke when the next in-order item is available to be output.

Stores the next item as it completes processing.

The ID of the item. The completed item. Specifies whether the item is valid (true) or just a placeholder (false).

Determines whether the specified id is next to be output, and if it is and if the item is "trusted" (meaning it may be output into the output action as-is), adds it.

The id of the item. The item. Whether to allow the item to be output directly if it is the next item. null if the item was added. true if the item was not added but is next in line. false if the item was not added and is not next in line.

Informs the reordering buffer not to expect the message with the specified id.

The id of the message to be ignored.

Outputs the item. The item must have already been confirmed to have the next ID.

The item to output. Whether the item is valid.

Gets a item count for debugging purposes.

Provides a debugger type proxy for the buffer.

The buffer being debugged.

Initializes the debug view.

The buffer being debugged.

Gets a dictionary of buffered items and their reordering IDs.

Gets the next ID required for outputting.

Provides a core implementation for blocks that implement .

Specifies the type of data supplied by the .

A TaskCompletionSource that represents the completion of this block.

A registry used to store all linked targets and information about them.

The output messages queued up to be received by consumers/targets.

The queue is only ever accessed by a single producer and single consumer at a time. On the producer side, we require that AddMessage/AddMessages are the only places the queue is added to, and we require that those methods not be used concurrently with anything else. All of our target halves today follow that restriction; for example, TransformBlock with DOP==1 will have at most a single task processing the user provided delegate, and thus at most one task calling AddMessage. If it has a DOP > 1, it'll go through the ReorderingBuffer, which will use a lock to synchronize the output of all of the processing tasks such that only one is using AddMessage at a time. On the consumer side of SourceCore, all consumption is protected by ValueLock, and thus all consumption is serialized.

Gets the object to use as the outgoing lock.

Gets the object to use as the value lock.

The source utilizing this helper.

The options used to configure this block's execution.

An action to be invoked on the owner block to stop accepting messages. This action is invoked when SourceCore encounters an exception.

An action to be invoked on the owner block when an item is removed. This may be null if the owner block doesn't need to be notified.

Item counting function

The task used to process the output and offer it to targets.

Counter for message IDs unique within this source block.

The target that the next message is reserved for, or null if nothing is reserved.

Whether all future messages should be declined.

Whether this block should again attempt to offer messages to targets.

Whether someone has reserved the right to call CompleteBlockOncePossible.

Exceptions that may have occurred and gone unhandled during processing.

Initializes the source core.

The source utilizing this core. The options to use to configure the block. Action to invoke in order to decline the associated target half, which will in turn decline this source core. Action to invoke when one or more items is removed. This may be null. Action to invoke when the owner needs to be able to count the number of individual items in an output or set of outputs.

Links the to the specified .

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of items available to be received from this block.

Adds a message to the source block for propagation. This method must only be used by one thread at a time, and must not be used concurrently with any other producer side methods, e.g. AddMessages, Complete.

The item to be wrapped in a message to be added.

Adds messages to the source block for propagation. This method must only be used by one thread at a time, and must not be used concurrently with any other producer side methods, e.g. AddMessage, Complete.

The list of items to be wrapped in messages to be added.

Adds an individual exceptionto this source.

The exception to add

Adds exceptions to this source.

The exceptions to add

Adds the exceptions contained in an AggregateException to this source.

The exception to add

Gets whether the _exceptions list is non-null.

Informs the block that it will not be receiving additional messages.

Gets the DataflowBlockOptions used to configure this block.

Offers messages to all targets.

The newly linked target, if OfferToTargets is being called to synchronously propagate to a target during a LinkTo operation.

Offers the message to the target.

The header of the message to offer. The message being offered. The single target to which the message should be offered. true if the message was accepted by the target; otherwise, false. true if the message should not be offered to additional targets; false if propagation should be allowed to continue.

Called when we want to enable asynchronously offering message to targets. Takes the ValueLock before delegating to OfferAsyncIfNecessary.

Called when we want to enable asynchronously offering message to targets.

Whether this call is the continuation of a previous message loop. Whether the caller is sure that the outgoing lock is currently held by this thread.

Called when we want to enable asynchronously offering message to targets.

Whether this call is the continuation of a previous message loop. Whether the caller is sure that the outgoing lock is currently held by this thread.

Task body used to process messages.

Gets whether the source has had cancellation requested or an exception has occurred.

Completes the block's processing if there's nothing left to do and never will be.

Slow path for CompleteBlockIfPossible. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Completes the block. This must only be called once, and only once all of the completion conditions are met. As such, it must only be called from CompleteBlockIfPossible.

Gets the object to display in the debugger display attribute.

Gets information about this helper to be used for display in a debugger.

Debugging information about this source core.

Provides debugging information about the source core.

The source being viewed.

Initializes the type proxy.

The source being viewed.

Gets the number of messages available for receiving.

Gets the messages available for receiving.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the set of all targets linked from this block.

Gets the target that holds a reservation on the next message, if any.

Provides a core implementation of for use when there's only a single producer posting data.

Specifies the type of data accepted by the .

The target block using this helper.

The messages in this target.

The options to use to configure this block. The target core assumes these options are immutable.

An action to invoke for every accepted message.

Exceptions that may have occurred and gone unhandled during processing. This field is lazily initialized.

Whether to stop accepting new messages.

A task has reserved the right to run the completion routine.

The Task currently active to process the block. This field is used to synchronize between producer and consumer, and it should not be set to null once the block completes, as doing so would allow for races where the producer gets another consumer task queued even though the block has completed.

A task representing the completion of the block. This field is lazily initialized.

Initialize the SPSC target core.

The owning target block. The action to be invoked for every message. The options to use to configure this block. The target core assumes these options are immutable.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Implements the slow path for OfferMessage.

The message header for the offered value. The offered value. The source offering the message. This may be null. true if we need to call back to the source to consume the message; otherwise, false if we can simply accept it directly. The status of the message.

Schedules a consumer task if there's none currently running.

Whether the new consumer is being scheduled to replace a currently running consumer.

Task body used to process messages.

Gets the number of messages waiting to be processed.

Completes the target core. If an exception is provided, the block will end up in a faulted state. If Complete is invoked more than once, or if it's invoked after the block is already completing, all invocations after the first are ignored.

The exception to be stored.

Ensures the exceptions list is initialized and stores the exception into the list using a lock.

The exception to store.

Completes the block. This must only be called once, and only once all of the completion conditions are met.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Gets the lazily-initialized completion source.

Gets the DataflowBlockOptions used to configure this block.

Gets information about this helper to be used for display in a debugger.

Debugging information about this target.

Gets the object to display in the debugger display attribute.

Provides a wrapper for commonly needed debugging information.

The target being viewed.

Initializes the debugging helper.

The target being viewed.

Gets the number of messages waiting to be processed.

Gets the messages waiting to be processed.

Gets the current number of outstanding input processing operations.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Options used to configure a target core.

Synchronous completion, both a target and a source, etc.

Whether the block relies on the delegate to signal when an async operation has completed.

Whether the block containing this target core is just a target or also has a source side. If it's just a target, then this target core's completion represents the entire block's completion.

Provides a core implementation of .

Specifies the type of data accepted by the .

Caching the keep alive predicate.

A task representing the completion of the block.

The target block using this helper.

The messages in this target.

This field doubles as the IncomingLock.

The options associated with this block.

An action to invoke for every accepted message.

Whether the block relies on the delegate to signal when an async operation has completed.

Bounding state for when the block is executing in bounded mode.

The reordering buffer used by the owner. May be null.

Gets the object used as the incoming lock.

Exceptions that may have occurred and gone unhandled during processing.

Whether to stop accepting new messages.

The number of operations (including service tasks) currently running asynchronously.

Must always be accessed from inside a lock.

The number of service tasks in async mode currently running.

Must always be accessed from inside a lock.

The next available ID we can assign to a message about to be processed.

A task has reserved the right to run the completion routine.

This counter is set by the processing loop to prevent itself from trying to keep alive.

Initializes the target core.

The target using this helper. An action to invoke for all accepted items. The reordering buffer used by the owner; may be null. The options to use to configure this block. The target core assumes these options are immutable. Options for how the target core should behave.

Internal Complete entry point with extra parameters for different contexts.

If not null, the block will be faulted. If true, any unprocessed input messages will be dropped. If true, an exception will be stored after _decliningPermanently has been set to true. If true, exception will be treated as an AggregateException. Indicates whether the processing state is dirty and has to be reverted.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Gets the number of items waiting to be processed by this target.

Signals to the target core that a previously launched asynchronous operation has now completed.

The number of elements by which to change the bounding count, if bounding is occurring.

Gets whether this instance has been constructed for async processing.

Gets whether there's room to launch more processing operations.

Gets whether there's room to launch more service tasks for doing/launching processing operations.

Called when new messages are available to be processed.

Whether this call is the continuation of a previous message loop.

Slow path for ProcessAsyncIfNecessary. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Task body used to process messages.

Retrieves the next message from the input queue for the useAsyncCompletion mode.

The next message retrieved. true if a message was found and removed; otherwise, false.

Either takes the next available message from the input queue or retrieves a postponed message from a source, based on whether we're in greedy or non-greedy mode.

The retrieved item with its Id. true if a message could be removed and returned; otherwise, false.

Consumes a single postponed message.

true if the method is being called to consume a message that'll then be stored into the input queue; false if the method is being called to consume a message that'll be processed immediately. If true, the bounding state's ForcePostponement will be updated. If false, the method will first try (while holding the lock) to consume from the input queue before consuming a postponed message. The consumed message. true if a message was consumed; otherwise, false.

Gets whether the target has had cancellation requested or an exception has occurred.

Completes the block once all completion conditions are met.

Slow path for CompleteBlockIfPossible. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Completes the block. This must only be called once, and only once all of the completion conditions are met. As such, it must only be called from CompleteBlockIfPossible.

Gets whether the target core is operating in a bounded mode.

Increases or decreases the bounding count.

The incremental addition (positive to increase, negative to decrease).

Gets the object to display in the debugger display attribute.

Gets the DataflowBlockOptions used to configure this block.

Gets information about this helper to be used for display in a debugger.

Debugging information about this target.

Provides a wrapper for commonly needed debugging information.

The target being viewed.

Initializes the debugging helper.

The target being viewed.

Gets the number of messages waiting to be processed.

Gets the messages waiting to be processed.

Gets any postponed messages.

Gets the current number of outstanding input processing operations.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Stores targets registered with a source.

Specifies the type of data accepted by the targets. This type is not thread-safe.

Information about a registered target. This class represents a self-sufficient node in a linked list.

Initializes the LinkedTargetInfo.

The target block reference for this entry. The link options.

The target block reference for this entry.

The value of the PropagateCompletion link option.

Number of remaining messages to propagate. This counter is initialized to the MaxMessages option and gets decremented after each successful propagation.

The previous node in the list.

The next node in the list.

A reference to the owning source block.

A mapping of targets to information about them.

The first node of an ordered list of targets. Messages should be offered to targets starting from First and following Next.

The last node of the ordered list of targets. This field is used purely as a perf optimization to avoid traversing the list for each Add.

Number of links with positive RemainingMessages counters. This is an optimization that allows us to skip dictionary lookup when this counter is 0.

Initializes the registry.

Adds a target to the registry.

The target to add. The link options.

Gets whether the registry contains a particular target.

The target. true if the registry contains the target; otherwise, false.

Removes the target from the registry.

The target to remove. Only remove the target if it's configured to be unlinked after one propagation.

Actually removes the target from the registry.

The target to remove. Only remove the target if it's configured to be unlinked after one propagation.

Clears the target registry entry points while allowing subsequent traversals of the linked list.

Propagated completion to the targets of the given linked list.

The head of a saved linked list.

Gets the first node of the ordered target list.

Adds a LinkedTargetInfo node to the doubly-linked list.

The node to be added. Whether to append or to prepend the node.

Removes the LinkedTargetInfo node from the doubly-linked list.

The node to be removed.

Gets the number of items in the registry.

Converts the linked list of targets to an array for rendering in a debugger.

Provides a nop passthrough for use with TargetRegistry.

The source that encapsulates this block.

The target with which this block is associated.

Initializes the passthrough.

The source that encapsulates this block. The target to which messages should be forwarded.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Links the to the specified .

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for a passthrough.

The passthrough.

Initializes the debug view.

The passthrough to view.

The linked target for this block.

Provides a debugger type proxy for the target registry.

The registry being debugged.

Initializes the type proxy.

The target registry.

Gets a list of all targets to show in the debugger.

Provides a buffer for storing at most one element at time, overwriting each message with the next as it arrives. Messages are broadcast to all linked targets, all of which may consume a clone of the message.

Specifies the type of the data buffered by this dataflow block. exposes at most one element at a time. However, unlike , that element will be overwritten as new elements are provided to the block. ensures that the current element is broadcast to any linked targets before allowing the element to be overwritten.

The source side.

Bounding state for when the block is executing in bounded mode.

Whether all future messages should be declined.

A task has reserved the right to run the completion routine.

Gets the lock used to synchronize incoming requests.

Initializes the with the specified cloning function.

The function to use to clone the data when offered to other blocks. This may be null to indicate that no cloning need be performed.

Initializes the with the specified cloning function and .

The function to use to clone the data when offered to other blocks. This may be null to indicate that no cloning need be performed. The options with which to configure this . The is null (Nothing in Visual Basic).

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Notifies the block that one or more items was removed from the queue.

The number of items removed.

Called when postponed messages may need to be consumed.

Whether this call is the continuation of a previous message loop.

Task body used to consume postponed messages.

Retrieves one postponed message if there's room and if we can consume a postponed message. Stores any consumed message into the source half.

true if a message could be consumed and stored; otherwise, false. This must only be called from the asynchronous processing loop.

Completes the target, notifying the source, once all completion conditions are met.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets a value to be used for the DebuggerDisplayAttribute. This must not throw even if HasValue is false.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the BroadcastBlock.

The BroadcastBlock being debugged.

Debug info about the source side of the broadcast.

Initializes the debug view.

The BroadcastBlock being debugged.

Gets the messages waiting to be processed.

Gets whether the broadcast has a current value.

Gets the broadcast's current value.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the block's Id.

Gets the set of all targets linked from this block.

Provides a core implementation for blocks that implement .

Specifies the type of data supplied by the .

A registry used to store all linked targets and information about them.

All of the output messages queued up to be received by consumers/targets.

A TaskCompletionSource that represents the completion of this block.

An action to be invoked on the owner block when an item is removed. This may be null if the owner block doesn't need to be notified.

Gets the object to use as the outgoing lock.

Gets the object to use as the value lock.

The source utilize this helper.

The options used to configure this block's execution.

The cloning function to use.

An indicator whether _currentMessage has a value.

The message currently being broadcast.

The target that the next message is reserved for, or null if nothing is reserved.

Whether this block should again attempt to offer messages to targets.

Whether all future messages should be declined.

The task used to process the output and offer it to targets.

Exceptions that may have occurred and gone unhandled during processing.

Counter for message IDs unique within this source block.

Whether someone has reserved the right to call CompleteBlockOncePossible.

Initializes the source core.

The source utilizing this core. The function to use to clone the data when offered to other blocks. May be null. The options to use to configure the block. Action to invoke when an item is removed.

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Adds a message to the source block for propagation.

The item to be wrapped in a message to be added.

Informs the block that it will not be receiving additional messages.

Clones the item.

The item to clone. The cloned item.

Offers the current message to a specific target.

The target to which to offer the current message.

Offers messages to targets.

Offers the specified message to the specified target.

The header of the message to offer. The message to offer. The target to which the message should be offered. This will remove the target from the target registry if the result of the propagation demands it.

Called when we want to enable asynchronously offering message to targets.

Whether this call is the continuation of a previous message loop.

Task body used to process messages.

Completes the block's processing if there's nothing left to do and never will be.

Slow path for CompleteBlockIfPossible. Separating out the slow path into its own method makes it more likely that the fast path method will get inlined.

Completes the block. This must only be called once, and only once all of the completion conditions are met. As such, it must only be called from CompleteBlockIfPossible.

Links the to the specified .

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets whether the source has had cancellation requested or an exception has occurred.

Adds an individual exceptionto this source.

The exception to add

Adds exceptions to this source.

The exceptions to add

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Gets the DataflowBlockOptions used to configure this block.

Gets the object to display in the debugger display attribute.

Gets information about this helper to be used for display in a debugger.

Debugging information about this source core.

Provides debugging information about the source core.

The source being viewed.

Initializes the type proxy.

The source being viewed.

Gets whether the source contains a current message.

Gets the value of the source's current message.

Gets the number of messages waiting to be made current.

Gets the messages available for receiving.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the set of all targets linked from this block.

Gets the target that holds a reservation on the next message, if any.

Provides a buffer for storing data.

Specifies the type of the data buffered by this dataflow block.

The core logic for the buffer block.

The bounding state for when in bounding mode; null if not bounding.

Whether all future messages should be declined on the target.

A task has reserved the right to run the target's completion routine.

Gets the lock object used to synchronize incoming requests.

Initializes the .

Initializes the with the specified .

The options with which to configure this . The is null (Nothing in Visual Basic).

Offers a message to the , giving the target the opportunity to consume or postpone the message.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of items currently stored in the buffer.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Notifies the block that one or more items was removed from the queue.

The number of items removed.

Called when postponed messages may need to be consumed.

Whether this call is the continuation of a previous message loop.

Task body used to consume postponed messages.

Retrieves one postponed message if there's room and if we can consume a postponed message. Stores any consumed message into the source half.

true if a message could be consumed and stored; otherwise, false. This must only be called from the asynchronous processing loop.

Completes the target, notifying the source, once all completion conditions are met.

Gets the number of messages in the buffer. This must only be used from the debugger as it avoids taking necessary locks.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the BufferBlock.

The buffer block.

The buffer's source half.

Initializes the debug view.

The BufferBlock being viewed.

Gets the collection of postponed message headers.

Gets the messages in the buffer.

The task used to process messages.

Gets the task being used for output processing.

Gets the DataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the block's Id.

Gets the set of all targets linked from this block.

Provides a dataflow block that joins across multiple dataflow sources, not necessarily of the same type, waiting for one item to arrive for each type before they?re all released together as a tuple of one item per type.

Specifies the type of data accepted by the block's first target. Specifies the type of data accepted by the block's second target.

Resources shared by all targets for this join block.

The source half of this join.

The first target.

The second target.

Initializes the .

The options with which to configure this . The is null (Nothing in Visual Basic).

Links the to the specified .

Attempts to synchronously receive an available output item from the .

Attempts to synchronously receive all available items from the .

Gets the number of output items available to be received from this block.

Gets a Task that represents the asynchronous operation and completion of the dataflow block.

Signals to the that it should not accept nor produce any more messages nor consume any more postponed messages.

Causes the to complete in a state.

Gets a target that may be used to offer messages of the first type.

Gets a target that may be used to offer messages of the second type.

Passes the ownership of the message identified by the from this instance to the .

Reserves the right to pass the ownership of the message identified by the from this to the .

Releases the right to pass the ownership of the message identified by the from this to the .

Gets the number of messages waiting to be processed. This must only be used from the debugger as it avoids taking necessary locks.

Returns a string that represents the formatted name of this instance.

Inherited from . Uses the option.

The data to display in the debugger display attribute.

Gets the data to display in the debugger display attribute for this instance.

Provides a debugger type proxy for the JoinBlock.

The JoinBlock being viewed.

The source half of the block being viewed.

Initializes the debug view.

The JoinBlock being viewed.

Gets the messages waiting to be received.

Gets the number of joins created thus far.

Gets the task being used for input processing.

Gets the task being used for output processing.

Gets the GroupingDataflowBlockOptions used to configure this block.

Gets whether the block is declining further messages.

Gets whether the block is completed.

Gets the block's Id.

Gets the first target.

Gets the second target.

Gets the set of all targets linked from this block.

Specifies the type of data accepted by the block's first target. Specifies the type of data accepted by the block's second target. Specifies the type of data accepted by the block's third target.

Resources shared by all targets for this join block.

The source half of this join.

The first target.

The second target.

The third target.