| Type | Description |
|---|
| type Async |
A 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 continuation or exception continuation.
Async computations are normally specified using the F# 'workflow' syntax for building computations.
Operationally, async computations typically run partly in the .NET Thread Pool via ThreadPool.QueueUserWorkItem,
and, when waiting for asynchronous I/O, they are suspended as thunks using ThreadPool.RegisterWaitForSingleObject,
waiting for the I/O completion.
Some primitive asynchronous computations necessarily end up executing blocking operations:
these should be run on a pool of threads specifically dedicated to resolving blocking conditions,
via UnblockedPrimitive. For example, FileOpen on Windows is, by design, a blocking operation.
However frequently it is important to code as if this is asynchronous. This can be done by running the
blocking operation via UnblockedPrimitive.
When run, async 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 | |
| type AsyncFuture |
A handle to an asynchronous computation. The Async.AsyncFuture member allows you to
spawn a computation and at a later point synchronize on its result.
Each AsyncFuture object may consume an OS resource in the form of a WaitHandle.
|
| type AsyncGroup |
A handle to a capability to cancel a set of asynchronous computations.
|
| type AsyncReplyChannel |
A handle to a capability to reply to a PostAndReply message
|
| type DelegateEvent | |
| type Event | |
| type Event | |
| type Handler | |
| 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<'a>,'a> |
| 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<'a> |
| 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 an asynchronous computation that includes the ability to read from a single dedicated
channel, i.e. a single dedicated message queue. Anyone can send messages to a MailboxProcessor by using the Post method.
A MailboxProcessor enters a state where it waits for the next message by calling its own Receive or TryReceive method.
A MailboxProcessor can scan through all available messages using its own Scan or TryScan method,
by using a function that selects an asynchronous computation to
run based on a scan of the message queue.
A MailboxProcessor generally needs to use one or more of its
own Receive, TryReceive, Scan or TryScan methods. It also often
typically has to allow other asynchronous computations to send
messages back to the MailboxProcessor. As a result the creation functions
are given a reference to the MailboxProcessor itself.
|