Microsoft.Ccr.Core Namespace
Microsoft Robotics
Microsoft Robotics Class Reference
| Class | Description | |
|---|---|---|
|
Arbiter |
Arbiter factory
|
|
Causality |
Logical context that flows across tasks
Causalities greatly simplify partial failure handling, by providing a multi threaded version of structured exception handling.
An exception port supplied within a causality can be used by any handler that was executed as a result of some root action.
Causalities deal with joins (merge of causalities) and forks, enabling a simple model for hierarchical handling of errors in a
concurrent setting |
|
CcrServiceBase |
Base CCR class
|
|
Choice |
The choice arbiter will arbitrate between N child receivers (branches) and only allow one to
proceed
|
|
ConcurrentReceiverGroup |
Receivers with user delegates that can run concurrently with each other
|
|
Dispatcher |
Implementation of the CCR Task Dispatcher/Scheduler
|
|
DispatcherQueue |
Special variant of a typed Port for enqueing and scheduling CCR Tasks
|
|
DispatcherQueueExtensions |
CCR DispatcherQueue Class Extensions
|
|
EmptyValue |
Utility type, with a singleton instance for use in signalling applications where no values need to be communicated
|
|
ExclusiveReceiverGroup |
Receivers with user delegates that must run exclusive to each other and any receiver in a Concurrent group
|
|
Interleave |
The Interleave arbiter is a generalization of reader/writer lock style synchronization
|
|
InterleaveReceiverGroup |
Receiver group
|
|
IterativeTask |
Zero argument Task instance associated with an iterator handler
|
|
IterativeTask<(Of <(<'T0>)>)> |
Container for iterator handlers and their arguments
|
|
IterativeTask<(Of <(<'T0, T1>)>)> |
Container for iterator handlers and their arguments
|
|
IterativeTask<(Of <(<'T0, T1, T2>)>)> |
Container for iterator handlers and their arguments
|
|
JoinReceiver |
Join implementation across multiple ports
|
|
JoinReceiverTask |
Shared logic for join arbiters
|
|
JoinSinglePortReceiver |
Join receiver that waits for N items all on the same port
|
|
MultipleItemGather |
Collects N messages from K ports, then executes a task passing K typed collections of messages
|
|
MultipleItemReceiver |
Collects N messages from N ports, then executes a task passing a collection with N messages
|
|
Port<(Of <(<'T>)>)> |
Type safe message queue and receiver attach point for the CCR.
|
|
PortExtensions |
Port extension methods for coordination primitive creation
|
|
PortNotFoundException |
Thrown when a message instance of incompatible type is posted on a Port instance
|
|
PortSet |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type specified at runtime
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSet<(Of <(<'T0, T1, T2, T3, T4, T5, T6, T7, T8>)>)> |
Multiple Queue Port composed out of multiple Port<T> instances, one for each type
For each generic type argument T, an instance of Port<T> is used to store messages of that type
Each Port<T> instance is independent of the others and there are non ordering guarantees across ports under the same
multiple port wrapper. To get access to the individual ports use the P0,P1,...,PN accessors
|
|
PortSetExtensions |
PortSet extension methods for coordination primitive creation
|
|
Receiver |
The most basic arbiter associates a user delegate (a receiver) with a port
|
|
Receiver<(Of <(<'T>)>)> |
Strongly typed version of Receiver
|
|
Shutdown |
Generic message type to signle shutdown.
|
|
SuccessFailurePort |
Port collection with ports typed for SuccessResult and Exception
|
|
SuccessResult |
Indicates success result
|
|
Task |
Implementation of ITask for zero argument handlers
|
|
Task<(Of <(<'T0>)>)> |
Container for typed, non-iterator handlers and their arguments
|
|
Task<(Of <(<'T0, T1>)>)> |
Container for typed, non-iterator handlers and their arguments
|
|
Task<(Of <(<'T0, T1, T2>)>)> |
Container for typed, non-iterator handlers and their arguments
|
|
TaskCommon |
Common base class for ITask implementations
|
|
TeardownReceiverGroup |
Receivers that will execute one time only after all concurrent and exclusive handlers
are finished. The interleave will then un register all receivers from ports and prevent
any further handlers form executing.
If multiple teardown receivers are present, only one will execute, the one that first has its
constraints (first one that receives a message for simple receives) met.
|
|
Tuple<(Of <(<'ITEM0>)>)> |
A type-safe, type-heterogeneous, item collection used for joins.
|
|
Tuple<(Of <(<'ITEM0, ITEM1>)>)> |
A type-safe, type-heterogeneous, item collection used for joins.
|
|
VariableArgumentTask<(Of <(<'T>)>)> |
A Task container with a variable number of typed arguments.
|
|
VariableArgumentTask<(Of <(<'T0, T>)>)> |
A Task container with a variable number of typed arguments.
|
| Interface | Description | |
|---|---|---|
|
ICausality |
Context for propagating failure and coordination ports across tasks
|
|
IPort |
Core interface abstracting CCR single type ports
|
|
IPortReceive |
Receiver registration and dequeuing methods for ports
|
|
IPortSet |
Required interface for multiple type ports with independent message queues
|
|
ITask |
Container for executable CCR code
|
| Delegate | Description | |
|---|---|---|
|
Handler |
Closure signature for message handler.
|
|
Handler<(Of <(<'T0>)>)> |
Closure signature for message handler.
|
|
Handler<(Of <(<'T0, T1>)>)> |
Closure signature for message handler.
|
|
Handler<(Of <(<'T0, T1, T2>)>)> |
Closure signature for message handler.
|
|
IteratorHandler |
Closure signature for iterator-based message handler.
|
|
IteratorHandler<(Of <(<'T0>)>)> |
Closure signature for iterator-based message handler.
|
|
IteratorHandler<(Of <(<'T0, T1>)>)> |
Closure signature for iterator-based message handler.
|
|
IteratorHandler<(Of <(<'T0, T1, T2>)>)> |
Closure signature for iterator-based message handler.
|
|
VariableArgumentHandler<(Of <(<'T>)>)> |
A typed delegate with a variable number of typed arguments preceding an array of instances of the same type.
|
|
VariableArgumentHandler<(Of <(<'T0, T>)>)> |
A typed delegate with a variable number of typed arguments preceding an array of instances of the same type.
|
| Enumeration | Description | |
|---|---|---|
|
DispatcherOptions |
Dispatcher configuration options
|
|
InterleaveReceivers |
Classification of interleave receiver groups
|
|
TaskExecutionPolicy |
Specifies dispatcher queue task scheduling behavior
|
Show: