Search Results for

    Show / Hide Table of Contents

    Namespace Akka.Streams.Dsl

    Classes

    AccumulateWhileUnchanged<TElement, TProperty>

    Accumulates elements of type TElement while extracted property of type TProperty remains unchanged, emits an accumulated sequence when the property changes

    Balance<T>

    Fan-out the stream to several streams. Each upstream element is emitted to the first available downstream consumer. It will not shut down until the subscriptions for at least two downstream subscribers have been established.

    A Balance<T> has one In port and 2 or more Out(int) ports.

    Emits when any of the outputs stops backpressuring; emits the element to the first available output

    Backpressures when all of the outputs backpressure

    Completes when upstream completes

    Cancels when all downstreams cancel

    BidiFlow

    TBD

    BidiFlow<TIn1, TOut1, TIn2, TOut2, TMat>

    TBD

    BroadcastHub

    A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers. It consists of two parts, a Sink<TIn, TMat> and a Source<TOut, TMat>. The Sink<TIn, TMat> broadcasts elements from a producer to the actually live consumers it has. Once the producer has been materialized, the Sink<TIn, TMat> it feeds into returns a materialized value which is the corresponding Source<TOut, TMat>. This Source<TOut, TMat> can be materialized arbitrary many times, where each of the new materializations will receive their elements from the original Sink<TIn, TMat>.

    Broadcast<T>

    Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers. It will not shut down until the subscriptions for at least two downstream subscribers have been established.

    Emits when all of the outputs stops backpressuring and there is an input element available

    Backpressures when any of the outputs backpressure

    Completes when upstream completes

    Cancels when If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel

    ChannelSink

    ChannelSource

    Container class for Akka.Streams Source<TOut, TMat> factory methods, which can be used to create sources from readable channels.

    Concat

    TBD

    Concat<TIn, TOut>

    Takes two streams and outputs one stream formed from the two input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream.

    A Concat<TIn, TOut> has one multiple In(int) ports and one Out port.

    Emits when the current stream has an element available; if the current input completes, it tries the next one

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    DelayFlow<T>

    Flow stage for universal delay management, allows to manage delay through IDelayStrategy<T>.

    FileIO

    TBD

    FixedDelay<T>

    Fixed delay strategy, always returns constant delay for any element.

    Flow

    A Flow is a set of stream processing steps that has one open input and one open output.

    FlowOperations

    The set of DSL methods for composing Flow<TIn, TOut, TMat> stages together.

    FlowWithContext

    FlowWithContextOperations

    FlowWithContext<TIn, TCtxIn, TOut, TCtxOut, TMat>

    A flow that provides operations which automatically propagate the context of an element. Only a subset of common operations from Flow is supported. As an escape hatch you can use [[FlowWithContextOps.via]] to manually provide the context propagation for otherwise unsupported operations.

    An "empty" flow can be created by calling Create<TIn, TCtx>().

    Flow<TIn, TOut, TMat>

    A Flow<TIn, TOut, TMat> is a set of stream processing steps that has one open input and one open output.

    ForwardOps

    TBD

    Framing

    TBD

    Framing.FramingException

    TBD

    GraphDsl

    A graph DSL, which defines an API for building complex graphs. Graph definitions are enclosed within a scope of functions defined by user, using a dedicated GraphDsl.Builder<T> helper to connect specific graph stages with each other.

    GraphDsl.Builder<T>

    TBD

    GraphDsl.ForwardOps<TOut, TMat>

    TBD

    GraphDsl.ReverseOps<TIn, TMat>

    TBD

    Interleave

    TBD

    Interleave<TIn, TOut>

    Interleave represents deterministic merge which takes N elements per input stream, in-order of inputs, emits them downstream and then cycles/"wraps-around" the inputs.

    Emits when element is available from current input (depending on phase)

    Backpressures when downstream backpressures

    Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true)

    Cancels when downstream cancels

    IntervalBasedRateLimiter

    JsonFraming

    Provides JSON framing stages that can separate valid JSON objects from incoming ByteString objects.

    Keep

    Convenience functions for often-encountered purposes like keeping only the left (first) or only the right (second) of two input values.

    KeepAliveConcat<T>

    Sends elements from buffer if upstream does not emit for a configured amount of time. In other words, this stage attempts to maintains a base rate of emitted elements towards the downstream using elements from upstream.

    If upstream emits new elements until the accumulated elements in the buffer exceed the specified minimum size used as the keep alive elements, then the base rate is no longer maintained until we reach another period without elements form upstream.

    The keep alive period is the keep alive failover size times the interval.

    Emits when upstream emits an element or if the upstream was idle for the configured period

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    LastElement<T>

    This stage materializes to the last element pushed before upstream completion, if any, thereby recovering from any failure. Pushed elements are just passed along.

    LinearIncreasingDelay<T>

    Strategy with linear increasing delay.

    MergeHub

    A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of producers. It consists of two parts, a Source<TOut, TMat> and a Sink<TIn, TMat>. The Source<TOut, TMat> streams the element to a consumer from its merged inputs. Once the consumer has been materialized, the Source<TOut, TMat> returns a materialized value which is the corresponding Sink<TIn, TMat>. This Sink<TIn, TMat> can then be materialized arbitrary many times, where each of the new materializations will feed its consumed elements to the original Source<TOut, TMat>.

    MergeHub.ProducerFailed

    TBD

    MergePreferred<T>

    Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).

    A MergePreferred<T> has one Out port, one Preferred input port and 0 or more secondary In(int) ports.

    Emits when one of the inputs has an element available, preferring a specified input if multiple have elements available

    Backpressures when downstream backpressures

    Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true)

    Cancels when downstream cancels

    MergePreferred<T>.MergePreferredShape

    TBD

    MergePrioritized<T>

    Merge several streams, taking elements as they arrive from input streams (picking from prioritized once when several have elements ready). A MergePrioritized<T> has one Out port, one or more input port with their priorities.

    Emits when one of the inputs has an element available, preferring a input based on its priority if multiple have elements available

    Backpressures when downstream backpressures

    Completes when all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is `false`

    Cancels when downstream cancels

    MergeSorted<T>

    Merge two pre-sorted streams such that the resulting stream is sorted.

    Emits when both inputs have an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    Merge<T>

    Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).

    Emits when one of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    Merge<TIn, TOut>

    Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).

    Emits when one of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    One2OneBidiFlow

    TBD

    One2OneBidi<TIn, TOut>

    TBD

    OrElse

    TBD

    OrElse<T>

    Takes two streams and passes the first through, the secondary stream is only passed through if the primary stream completes without passing any elements through. When the first element is passed through from the primary the secondary is cancelled. Both incoming streams are materialized when the stage is materialized.

    On errors the stage is failed regardless of source of the error.

    '''Emits when''' element is available from primary stream or the primary stream closed without emitting any elements and an element is available from the secondary stream

    '''Backpressures when''' downstream backpressures

    '''Completes when''' the primary stream completes after emitting at least one element, when the primary stream completes without emitting and the secondary stream already has completed or when the secondary stream completes

    '''Cancels when''' downstream cancels

    OutputTruncationException

    TBD

    PagedSource

    PagedSource.Page<T, TKey>

    Page for PagedSource.

    PartitionHub

    A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers. It consists of two parts, a Sink<TIn, TMat> and a Source<TOut, TMat>. The Sink<TIn, TMat> e elements from a producer to the actually live consumers it has.The selection of consumer is done with a function. Each element can be routed to only one consumer.Once the producer has been materialized, the Sink<TIn, TMat> it feeds into returns a materialized value which is the corresponding Source<TOut, TMat>. This Source<TOut, TMat> can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink<TIn, TMat>.

    PartitionOutOfBoundsException

    TBD

    PartitionWith<TIn, TOut0, TOut1>

    This stage partitions input to 2 different outlets, applying different transformations on the elements, according to the partition function.

    Partition<T>

    Fan-out the stream to several streams. emitting an incoming upstream element to one downstream consumer according to the partitioner function applied to the element

    Emits when an element is available from the input and the chosen output has demand

    Backpressures when the currently chosen output back-pressures

    Completes when upstream completes and no output is pending

    Cancels when when all downstreams cancel

    Pulse<T>

    Pulse stage signals demand only once every "pulse" interval and then back-pressures. Requested element is emitted downstream if there is demand. It can be used to implement simple time-window processing where data is aggregated for predefined amount of time and the computed aggregate is emitted once per this time.

    RestartFlow

    A RestartFlow wraps a Flow that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Flow can necessarily guarantee it will, for example, for Flow streams that depend on a remote server that may crash or become partitioned. The RestartFlow ensures that the graph can continue running while the Flow restarts.

    RestartSink

    A RestartSink wraps a Sink that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Sink can necessarily guarantee it will, for example, for Sink streams that depend on a remote server that may crash or become partitioned. The RestartSink ensures that the graph can continue running while the Sink restarts.

    RestartSource

    A RestartSource wraps a Source that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Source can necessarily guarantee it will, for example, for Source streams that depend on a remote server that may crash or become partitioned. The RestartSource ensures that the graph can continue running while the Source restarts.

    RestartWithBackoffFlow

    RestartWithBackoffFlow.Delay

    Temporary attribute that can override the time a [[RestartWithBackoffFlow]] waits for a failure before cancelling. See https://github.com/akka/akka/issues/24529 Should be removed if/when cancellation can include a cause.

    Retry

    ReuseLatest<T>

    Reuses the latest element from upstream until it's replaced by a new value.

    This is designed to allow fan-in stages where output from one of the sources is intermittent / infrequent and users just want the previous value to be reused.

    ReverseOps

    TBD

    RunnableGraph

    TBD

    RunnableGraph<TMat>

    A completed Akka.Streams graph that can be executed.

    Sample<T>

    Supports sampling on stream

    Sink

    TBD

    SinkQueueAsyncEnumerator<T>

    Wraps a Sink Queue and Killswitch around IAsyncEnumerator<T>

    Sink<TIn, TMat>

    A Sink<TIn, TMat> is a set of stream processing steps that has one open input. Can be used as a Reactive.Streams.ISubscriber<T>

    Source

    TBD

    SourceGen

    SourceOperations

    TBD

    SourceWithContext

    SourceWithContextOperations

    SourceWithContext<TOut, TCtx, TMat>

    A source that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOperations is supported. As an escape hatch you can use [[FlowWithContextOps.via]] to manually provide the context propagation for otherwise unsupported operations.

    Source<TOut, TMat>

    A Source<TOut, TMat> is a set of stream processing steps that has one open output. It can comprise any number of internal sources and transformations that are wired together, or it can be an "atomic" source, e.g. from a collection or a file. Materialization turns a Source into a Reactive Streams Reactive.Streams.IPublisher<T> (at least conceptually).

    StreamConverters

    Converters for interacting with the IO streams APIs

    StreamRefs

    API MAY CHANGE: The functionality of stream refs is working, however it is expected that the materialized value will eventually be able to remove the Task wrapping the stream references. For this reason the API is now marked as API may change. See ticket https://github.com/akka/akka/issues/24372 for more details.

    Factories for creating stream refs.

    StreamsAsyncEnumerableRerunnable<T, TMat>

    Used to treat an IRunnableGraph<TMat> of ISinkQueue<T> as an IAsyncEnumerable<T>

    SubFlowOperations

    TBD

    SubFlow<TOut, TMat, TClosed>

    A "stream of streams" sub-flow of data elements, e.g. produced by Akka.Streams.Implementation.Fusing.GroupBy<T, TKey>. SubFlows cannot contribute to the super-flow’s materialized value since they are materialized later, during the runtime of the flow graph processing.

    Tcp

    TBD

    TcpExt

    TBD

    TcpIdleTimeoutException

    TcpStreamExtensions

    TBD

    UnZip<T1, T2>

    Takes a stream of pair elements and splits each pair to two output streams.

    An UnZip<T1, T2> has one in port and one left and one right output port.

    Emits when all of the outputs stops backpressuring and there is an input element available

    Backpressures when any of the outputs backpressure

    Completes when upstream completes

    Cancels when any downstream cancels

    UnexpectedOutputException

    TBD

    UnzipWith

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1>

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1, TOut2>

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3>

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4>

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5>

    TBD

    UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>

    TBD

    UnzipWith<TIn, T0, T1>

    TBD

    UnzipWith<TIn, T0, T1, T2>

    TBD

    UnzipWith<TIn, T0, T1, T2, T3>

    TBD

    UnzipWith<TIn, T0, T1, T2, T3, T4>

    TBD

    UnzipWith<TIn, T0, T1, T2, T3, T4, T5>

    TBD

    UnzipWith<TIn, T0, T1, T2, T3, T4, T5, T6>

    TBD

    Valve<T>

    Materializes into a task of IValveSwitch which provides a method that will stop or restart the flow of elements passing through the stage. As long as the valve is closed it will backpressure. Note that closing the valve could result in one element being buffered inside the stage, and if the stream completes or fails while being closed, that element may be lost.

    WireTap

    ZipN

    TBD

    ZipN<T>

    Combine the elements of multiple streams into a stream of sequences. A ZipN<T> has a n input ports and one out port

    Emits when all of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    ZipWith

    TBD

    ZipWithN

    TBD

    ZipWithN<TIn, TOut>

    Combine the elements of multiple streams into a stream of sequences using a combiner function. A ZipWithN<TIn, TOut> has a n input ports and one out port

    Emits when all of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TIn8, TOut>

    TBD

    ZipWith<TIn0, TIn1, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TIn3, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TOut>

    TBD

    ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TOut>

    TBD

    Zip<T1, T2>

    Combine the elements of 2 streams into a stream of tuples.

    A Zip<T1, T2> has a left and a right input port and one out port

    Emits when all of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    Structs

    Tcp.IncomingConnection

    Represents an accepted incoming TCP connection.

    Tcp.OutgoingConnection

    Represents a prospective outgoing TCP connection.

    Tcp.ServerBinding

    Represents a successful TCP server binding.

    Interfaces

    IDelayStrategy<T>

    Allows to manage delay and can be stateful to compute delay for any sequence of elements, all elements go through NextDelay(T) updating state and returning delay for each element

    IFlow<TOut, TMat>

    Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.

    IRunnableGraph<TMat>

    Flow with attached input and output, can be executed.

    IUnzipWithCreator<TIn, TOut, T>

    TBD

    IValveSwitch

    Pause/resume a Flow

    PartitionHub.IConsumerInfo

    DO NOT INHERIT

    Enums

    SwitchMode

    Mode for IValveSwitch

    In this article
    Back to top
    Contribute
    • Project Chat
    • Discussion Forum
    • Source Code
    Support
    • Akka.NET Support Plans
    • Akka.NET Observability Tools
    • Akka.NET Training & Consulting
    Maintained By
    • Petabridge - The Akka.NET Company
    • Learn Akka.NET