/// <summary> /// Creates a <see cref="Channel{T}"/> instance accordingly to the provided capacity. /// If greater than 0, the channel will be bounded; otherwise unbounded. /// </summary> public static Channel <T> CreateForCapacity <T>( int capacity, bool singleReader = false, bool singleWriter = false, bool allowSynchronousContinuations = false, BoundedChannelFullMode fullMode = BoundedChannelFullMode.Wait) { if (capacity > 0) { return(Channel.CreateBounded <T>(new BoundedChannelOptions(capacity) { SingleReader = singleReader, SingleWriter = singleWriter, AllowSynchronousContinuations = allowSynchronousContinuations, FullMode = fullMode })); } return(Channel.CreateUnbounded <T>(new UnboundedChannelOptions() { SingleReader = singleReader, SingleWriter = singleWriter, AllowSynchronousContinuations = allowSynchronousContinuations })); }
public ChannelReaderSink(int bufferSize, bool singleReader = false, BoundedChannelFullMode fullMode = BoundedChannelFullMode.Wait) { _bufferSize = bufferSize; _singleReader = singleReader; _fullMode = fullMode; Inlet = new Inlet <T>("channelReader.in"); Shape = new SinkShape <T>(Inlet); }
/// <summary>Initializes the <see cref="BoundedChannel{T}"/>.</summary> /// <param name="bufferedCapacity">The positive bounded capacity for the channel.</param> /// <param name="mode">The mode used when writing to a full channel.</param> /// <param name="runContinuationsAsynchronously">Whether to force continuations to be executed asynchronously.</param> internal BoundedChannel(int bufferedCapacity, BoundedChannelFullMode mode, bool runContinuationsAsynchronously) { Debug.Assert(bufferedCapacity > 0); _bufferedCapacity = bufferedCapacity; _mode = mode; _runContinuationsAsynchronously = runContinuationsAsynchronously; _completion = new TaskCompletionSource <VoidResult>(runContinuationsAsynchronously ? TaskCreationOptions.RunContinuationsAsynchronously : TaskCreationOptions.None); Reader = new BoundedChannelReader(this); Writer = new BoundedChannelWriter(this); }
/// <summary>Creates a channel with the specified bounded size.</summary> /// <typeparam name="T">Specifies the type of data in the channel.</typeparam> /// <param name="bufferedCapacity">The maximum number of elements the channel can store.</param> /// <param name="mode">The behavior to use when writing to a full channel.</param> /// <param name="optimizations">Controls optimizations that may be applied to the channel.</param> /// <returns>The created channel.</returns> public static Channel <T> CreateBounded <T>(int bufferedCapacity, BoundedChannelFullMode mode = BoundedChannelFullMode.Wait, ChannelOptimizations optimizations = null) { if (bufferedCapacity < 1) { throw new ArgumentOutOfRangeException(nameof(bufferedCapacity)); } if (mode != BoundedChannelFullMode.DropNewest && mode != BoundedChannelFullMode.DropOldest && mode != BoundedChannelFullMode.Wait) { throw new ArgumentOutOfRangeException(nameof(mode)); } bool runContinuationsAsynchronously = optimizations == null || !optimizations.AllowSynchronousContinuations; return(new BoundedChannel <T>(bufferedCapacity, mode, runContinuationsAsynchronously)); }
protected BaseChannelWorkTask(Channel <TDataModel> channel, Action <TDataModel> workAction, int workTaskTotalCount, int taskSleepMilliseconds, int channelCapacityCount, BoundedChannelFullMode channelFullMode) { if (workAction.IfIsNull()) { throw new ArgumentNullException(nameof(workAction)); } if (workTaskTotalCount < 1) { workTaskTotalCount = 1; } if (taskSleepMilliseconds <= 0) { taskSleepMilliseconds = 3 * 1000; } if (channelCapacityCount < 0) { channelCapacityCount = 0; } WorkTaskTotalCount = workTaskTotalCount; _CurrentWorkAction = workAction; ChannelCapacityCount = channelCapacityCount; ChannelFullMode = channelFullMode; TaskSleepMilliseconds = taskSleepMilliseconds; if (!channel.IfIsNull()) { _IsInternalChannel = true; _CurrentChannel = channel; } }
public void BoundedChannelOptions_InvalidModes_ThrowArgumentExceptions(BoundedChannelFullMode mode) => AssertExtensions.Throws <ArgumentOutOfRangeException>("value", () => new BoundedChannelOptions(1) { FullMode = mode });
public void CreateBounded_InvalidModes_ThrowArgumentExceptions(BoundedChannelFullMode mode) { Assert.Throws <ArgumentOutOfRangeException>("mode", () => Channel.CreateBounded <int>(1, mode)); }
public WorkTaskQueue(Action<TDataModel> workAction, int workTaskTotalCount = 1, int taskSleepMilliseconds = 3 * 1000, int channelCapacityCount = 0, BoundedChannelFullMode channelFullMode = BoundedChannelFullMode.Wait) : this(null, workAction, workTaskTotalCount, taskSleepMilliseconds, channelCapacityCount, channelFullMode) { }
internal WorkTaskQueue(Channel<TDataModel> channel, Action<TDataModel> workAction, int workTaskTotalCount, int taskSleepMilliseconds, int channelCapacityCount, BoundedChannelFullMode channelFullMode) : base(channel, workAction, workTaskTotalCount, taskSleepMilliseconds, channelCapacityCount, channelFullMode) { }
internal WorkTaskTriggerQueue(Channel <TDataModel> channel, Action <List <TDataModel> > workTriggerAction, ushort actionTriggerCount, TimeSpan actionTriggerTimeSpan, int taskSleepMilliseconds = 3000, int channelCapacityCount = 0, BoundedChannelFullMode channelFullMode = BoundedChannelFullMode.Wait) : base(channel, workTriggerAction, actionTriggerCount, actionTriggerTimeSpan, taskSleepMilliseconds, channelCapacityCount, channelFullMode) { }
/// <summary> /// Creates a sink that upon materialization, returns a <see cref="ChannelReader{T}"/> connected with /// this materialized graph. It can then be used to consume events incoming from the graph. It will /// also be completed once upstream completes. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="bufferSize"></param> /// <param name="singleReader"></param> /// <param name="fullMode"></param> /// <returns></returns> public static Sink <T, ChannelReader <T> > AsReader <T>(int bufferSize, bool singleReader = false, BoundedChannelFullMode fullMode = BoundedChannelFullMode.Wait) => Sink.FromGraph(new ChannelReaderSink <T>(bufferSize, singleReader));