Namespace Akka.IO

Classes

ByteString

A rope-like immutable data structure containing bytes. The goal of this structure is to reduce copying of arrays when concatenating and slicing sequences of bytes, and also providing a thread safe way of working with bytes.

Dns

Extension for DNS resolution support in Akka.NET.

Dns.Command

TBD

Dns.Resolve

Command to resolve a DNS name.

Dns.Resolved

Result of a DNS resolution.

DnsBase

Base class for DNS resolution backends.

DnsExt

TBD

DnsExt.DnsSettings

TBD

IOExtension

An Akka.IO Extension

Inet

TBD

Inet.AbstractSocketOption

TBD

Inet.AbstractSocketOptionV2

TBD

Inet.DatagramChannelCreator

TBD

Inet.SO

TBD

Inet.SO.ReceiveBufferSize

TBD

Inet.SO.ReuseAddress

TBD

Inet.SO.SendBufferSize

TBD

Inet.SO.TrafficClass

TBD

Inet.SoForwarders

TBD

Inet.SocketOption

TBD

Inet.SocketOptionV2

TBD

InetAddressDnsProvider

TBD

InetAddressDnsResolver

TBD

SimpleDnsCache

A simple in-memory DNS cache that stores resolved DNS entries with TTL-based expiration.

SimpleDnsManager

Actor that manages DNS resolution requests and the DNS cache.

Tcp

The set of TCP capabilities for Akka.IO are exposed via this extension.

Tcp.Abort

An abort operation will not flush pending writes and will issue a TCP ABORT command to the O/S kernel which should result in a TCP_RST packet being sent to the peer. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.Aborted message.

Tcp.Aborted

The connection has been aborted in response to an Tcp.Abort command.

Tcp.Bind

The Bind message is send to the TCP manager actor, which is obtained via Manager in order to bind to a listening socket. The manager replies either with a Tcp.CommandFailed or the actor handling the listen socket replies with a Tcp.Bound message. If the local port is set to 0 in the Bind message, then the Tcp.Bound message should be inspected to find the actual port which was bound to.

Tcp.Bound

The sender of a Tcp.Bind command will—in case of success—receive confirmation in this form. If the bind address indicated a 0 port number, then the contained localAddress can be used to find out which port was automatically assigned.

Tcp.Close

A normal close operation will first flush pending writes and then close the socket. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.Closed message.

Tcp.CloseCommand

Common interface for all commands which aim to close down an open connection.

Tcp.Closed

The connection has been closed normally in response to a Tcp.Close command.

Tcp.Command

All Akka.IO.Tcp commands inherit from this class.

Tcp.CommandFailed

Whenever a command cannot be completed, the queried actor will reply with this message, wrapping the original command which failed.

Tcp.CompoundWrite

A write command which aggregates two other write commands. Using this construct you can chain a number of Tcp.Write commands together in a way that allows them to be handled as a single write which gets written out to the network as quickly as possible. If the sub commands contain ack requests they will be honored as soon as the respective write has been written completely.

Tcp.ConfirmedClose

A confirmed close operation will flush pending writes and half-close the connection, waiting for the peer to close the other half. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.ConfirmedClosed message.

Tcp.ConfirmedClosed

The connection has been half-closed by us and then half-close by the peer in response to a Tcp.ConfirmedClose command.

Tcp.Connect

The Connect message is sent to the TCP manager actor, which is obtained via Manager. Either the manager replies with a Tcp.CommandFailed or the actor handling the new connection replies with a Tcp.Connected message.

Tcp.Connected

The connection actor sends this message either to the sender of a Tcp.Connect command (for outbound) or to the handler for incoming connections designated in the Tcp.Bind message. The connection is characterized by the remoteAddress and localAddress TCP endpoints.

Tcp.ConnectionClosed

This is the common interface for all events which indicate that a connection has been closed or half-closed.

Tcp.ErrorClosed

The connection has been closed due to an IO error.

Tcp.Event

Common interface for all events generated by the TCP layer actors.

Tcp.Message

Akka.IO Tcp messages are all derived from this class.

Tcp.NoAck

Each Tcp.WriteCommand can optionally request a positive acknowledgment to be sent to the commanding actor. If such notification is not desired the Ack must be set to an instance of this class. The token contained within can be used to recognize which write failed when receiving a Tcp.CommandFailed message.

Tcp.PeerClosed

The peer has closed its writing half of the connection.

Tcp.Received

Whenever data are read from a socket they will be transferred within this class to the handler actor which was designated in the Tcp.Register message.

Tcp.Register

This message must be sent to a TCP connection actor after receiving the Tcp.Connected message. The connection will not read any data from the socket until this message is received, because this message defines the actor which will receive all inbound data.

Tcp.ResumeAccepting

This message enables the accepting of the next connection if read throttling is enabled for connection actors.

Tcp.ResumeReading

This command needs to be sent to the connection actor after a Tcp.SuspendReading command in order to resume reading from the socket.

Tcp.ResumeWriting

When useResumeWriting is in effect as was indicated in the Tcp.Register message then this command needs to be sent to the connection actor in order to re-enable writing after a Tcp.CommandFailed event. All Tcp.WriteCommand processed by the connection actor between the first Tcp.CommandFailed and subsequent reception of this message will also be rejected with Tcp.CommandFailed.

Tcp.SimpleWriteCommand

A non-compounded write

Tcp.SubscribeToTcpListenerStats

Subscribe to receive ongoing statistics from a TCP listener. See Tcp.TcpListenerStatistics

Tcp.SuspendReading

Sending this command to the connection actor will disable reading from the TCP socket. TCP flow-control will then propagate backpressure to the sender side as buffers fill up on either end. To re-enable reading send Tcp.ResumeReading.

Tcp.TcpListenerStatistics

A set of statistics from a specific TCP listener.

Tcp.Unbind

In order to close down a listening socket, send this message to that socket’s actor (that is the actor which previously had sent the Tcp.Bound message). The listener socket actor will reply with a Tcp.Unbound message.

Tcp.Unbound

The sender of an Tcp.Unbind command will receive confirmation through this message once the listening socket has been closed.

Tcp.UnsubscribeFromTcpListenerStats

Unsubscribe from receiving ongoing statistics from a TCP listener.

Tcp.Write

Write data to the TCP connection. If no ack is needed use the special NoAck object. The connection actor will reply with a Tcp.CommandFailed message if the write could not be enqueued. If Write.WantsAck returns true, the connection actor will reply with the supplied Ack token once the write has been successfully enqueued to the O/S kernel. Note that this does not in any way guarantee that the data will be or have been sent! Unfortunately there is no way to determine whether a particular write has been sent by the O/S.

Tcp.WriteCommand

All write commands inherit from this class.

Tcp.WritingResumed

When useResumeWriting is in effect as indicated in the Tcp.Register message, the Tcp.ResumeWriting command will be acknowledged by this message type, upon which it is safe to send at least one write. This means that all writes preceding the first Tcp.CommandFailed message have been enqueued to the O/S kernel at this point.

TcpExt

Akka.IO TCP extension - provides an actor-based API for TCP socket communication.

TcpExtensions

Convenience methods for using the Akka.IO.Tcp extension.

TcpMessage

Helpers for generating TCP messages.

TcpSettings

TBD

Udp

UDP Extension for Akka's IO layer.

This extension implements the connectionless UDP protocol without calling connect on the underlying sockets, i.e. without restricting from whom data can be received. For "connected" UDP mode see UdpConnected.

For a full description of the design and philosophy behind this IO implementation please refer to the Akka online documentation.

Udp.Bind

Send this message to the Manager in order to bind to the given local port (or an automatically assigned one if the port number is zero). The listener actor for the newly bound port will reply with a Udp.Bound message, or the manager will reply with a Udp.CommandFailed message.

Udp.Bound

This message is sent by the listener actor in response to a Udp.Bind command. If the address to bind to specified a port number of zero, then this message can be inspected to find out which port was automatically assigned.

Udp.Command

The common type of all commands supported by the UDP implementation.

Udp.CommandFailed

When a command fails it will be replied to with this message type, wrapping the failing command object.

Udp.Event

The common type of all events emitted by the UDP implementation.

Udp.Message

The common interface for Udp.Command and Udp.Event.

Udp.NoAck

Each Udp.Send can optionally request a positive acknowledgment to be sent to the commanding actor. If such notification is not desired the Ack must be set to an instance of this class. The token contained within can be used to recognize which write failed when receiving a Udp.CommandFailed message.

Udp.Received

When a listener actor receives a datagram from its socket it will send it to the handler designated in the Udp.Bind message using this message type.

Udp.ResumeReading

This message must be sent to the listener actor to re-enable reading from the socket after a SuspendReading command.

Udp.SO

Socket option forwarders specific to UDP.

Udp.SO.Broadcast

Inet.SocketOption to set the SO_BROADCAST option

For more information see cref="System.Net.Sockets.Socket.EnableBroadcast"/>

Udp.Send

This message is understood by the "simple sender" which can be obtained by sending the Udp.SimpleSender query to the Manager as well as by the listener actors which are created in response to Udp.Bind. It will send the given payload data as one UDP datagram to the given target address. The UDP actor will respond with Udp.CommandFailed if the send could not be enqueued to the O/S kernel because the send buffer was full. If the given ack is not of type Udp.NoAck the UDP actor will reply with the given object as soon as the datagram has been successfully enqueued to the O/S kernel.

The sending UDP socket's address belongs to the "simple sender" which does not handle inbound datagrams and sends from an ephemeral port; therefore sending using this mechanism is not suitable if replies are expected, use Udp.Bind in that case.

Udp.SimpleSender

Retrieve a reference to a "simple sender" actor of the UDP extension. The newly created "simple sender" will reply with the Udp.SimpleSenderReady notification.

The "simple sender" is a convenient service for being able to send datagrams when the originating address is meaningless, i.e. when no reply is expected.

The "simple sender" will not stop itself, you will have to send it a PoisonPill when you want to close the socket.

Udp.SimpleSenderReady

The "simple sender" sends this message type in response to a Udp.SimpleSender query.

Udp.SuspendReading

Send this message to a listener actor (which sent a Udp.Bound message) to have it stop reading datagrams from the network. If the O/S kernel's receive buffer runs full then subsequent datagrams will be silently discarded. Re-enable reading from the socket using the ResumeReading command.

Udp.Unbind

Send this message to the listener actor that previously sent a Udp.Bound message in order to close the listening socket. The recipient will reply with an Udp.Unbound message.

Udp.Unbound

This message is sent by the listener actor in response to an Unbind command after the socket has been closed.

UdpConnected

UDP Extension for Akka's IO layer.

This extension implements the connectionless UDP protocol with calling connect on the underlying sockets, i.e. with restricting from whom data can be received. For "unconnected" UDP mode see Udp.

For a full description of the design and philosophy behind this IO implementation please refer to the Akka online documentation.

UdpConnected.Command

The common type of all commands supported by the UDP implementation.

UdpConnected.CommandFailed

When a command fails it will be replied to with this message type, wrapping the failing command object.

UdpConnected.Connect

Send this message to the Manager in order to bind to a local port (optionally with the chosen localAddress) and create a UDP socket which is restricted to sending to and receiving from the given remoteAddress. All received datagrams will be sent to the designated handler actor.

UdpConnected.Connected

This message is sent by the connection actor to the actor which sent the UdpConnected.Connect message when the UDP socket has been bound to the local and remote addresses given.

UdpConnected.Disconnect

Send this message to a connection actor (which had previously sent the UdpConnected.Connected message) in order to close the socket. The connection actor will reply with a UdpConnected.Disconnected message.

UdpConnected.Disconnected

This message is sent by the connection actor to the actor which sent the Disconnect message when the UDP socket has been closed.

UdpConnected.Event

The common type of all events emitted by the UDP implementation.

UdpConnected.Message

The common interface for UdpConnected.Command and UdpConnected.Event.

UdpConnected.NoAck

Each UdpConnected.Send can optionally request a positive acknowledgment to be sent to the commanding actor. If such notification is not desired the Ack must be set to an instance of this class. The token contained within can be used to recognize which write failed when receiving a UdpConnected.CommandFailed message.

UdpConnected.Received

When a connection actor receives a datagram from its socket it will send it to the handler designated in the Udp.Bind message using this message type.

UdpConnected.ResumeReading

This message must be sent to the listener actor to re-enable reading from the socket after a SuspendReading command.

UdpConnected.Send

This message is understood by the connection actors to send data to their designated destination. The connection actor will respond with UdpConnected.CommandFailed if the send could not be enqueued to the O/S kernel because the send buffer was full. If the given ack is not of type UdpConnected.NoAck the connection actor will reply with the given object as soon as the datagram has been successfully enqueued to the O/S kernel.

Namespace Akka.IO

Classes

Interfaces

Enums