| Type | Description |
|---|
| type Async |
An asynchronous computation, which, when run, will eventually produce a value
of the given type, or else raise an exception. The value and/or exception is not returned
to the caller immediately, but is rather passed to a success continuation, exception continuation
or cancellation continuation.
Asynchronous computations are normally specified using the F# 'workflow' syntax for building
computations.
When run, asynchronous computations can normally be thought of as running run in one of
two modes: 'work item mode' or 'waiting mode'.
- 'work item mode' indicates that the computation is executing as a work item,
e.g. in the .NET Thread Pool via ThreadPool.QueueUserWorkItem, or is running
a brief event-response action on the GUI thread.
- 'waiting mode' indicates the computations a waiting for asynchronous I/O completions,
typically suspended as thunks using ThreadPool.RegisterWaitForSingleObject.
Asynchronous computations running as 'work items' should not generally perform blocking
operations, e.g. long running synchronous loops. However, some asynchronous
computations may, out of necessity, need to execute blocking I/O operations:
these should be run on new threads or a user-managed pool of threads specifically
dedicated to resolving blocking conditions. For example, System.IO.OpenFile is, by
design, a blocking operation. However frequently it is important to code as
if this is asynchronous. This can be done by executing Async.SwitchToNewThread
as part of the workflow.
When run, asynchronous computations belong to an AsyncGroup. This can usually be specified
when the async computation is started. The only action on an AsyncGroup is to raise a cancellation
condition for the AsyncGroup. Async values check the cancellation condition for their AsyncGroup
regularly, though synchronous computations within an asynchronous computation will not automatically
check this condition. This gives a user-level cooperative cancellation protocol.
|
| type Async |
This static class holds members for creating and manipulating asynchronous computations
|
| type AsyncBuilder |
The type of the 'async' operator, used to build workflows for asynchronous computations.
|
| type AsyncGroup | |
| type AsyncReplyChannel |
A handle to a capability to reply to a PostAndReply message
|
| type DelegateEvent |
Event implementations for an arbitrary type of delegate
|
| type Event |
Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument
|
| type Event |
Event implementations for the IEvent<_> type
|
| type Handler |
A delegate type associated with the F# event type IEvent<_>
|
| type IDelegateEvent |
F# gives special status to non-virtual instance member properties compatible with type IDelegateEvent,
generating approriate .NET metadata to make the member appear to other .NET languages as a
.NET event.
|
| type IEvent |
The family of first class event values for delegate types that satisfy the F# delegate constraint.
|
| type IEvent |
First-class listening points (i.e. objects that permit you to register a 'callback'
activated when the event is triggered). See the module Event
for functions to create events.
Note: an abbreviation for IEvent<Handler<'T>,'T> |
| type lazy |
The type of delayed computations.
Use the values in the Lazy module to manipulate
values of this type, and the notation 'lazy expr' to create values
of this type.
Note: an abbreviation for Lazy<'T> |
| type Lazy |
The type of delayed computations.
Use the values in the Lazy module to manipulate
values of this type, and the notation 'lazy expr' to create values
of this type.
|
| type MailboxProcessor |
A MailboxProcessor is a message-processing agent defined using an asynchronous workflow.
The agent encapsulates a message queue that supports multiple-writers and the single reader agent.
Writers send messages to the agent by using the Post, PostAndReply or AsyncPostAndReply methods.
The reader agent is specified when creating the MailboxProcessor. The
agent is usually an asychronous workflow that waits for messages
by using the Receive or TryReceive methods.
A MailboxProcessor may also scan through all available messages by using the
Scan or TryScan method. The encapsulated message queue only
supports a single active reader, thus at most one concurrent call to Receive, TryReceive,
Scan and/or TryScan may be active at any one time.
|
| type OperationCanceledException | |