/// <summary> /// Constructs a simple dataflow from an target block /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <param name="block">an target block to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <param name="name">Name of the returned dataflow</param> /// <returns>A dataflow that wraps the target block</returns> public static Dataflow <TIn> ToDataflow <TIn>(this ITargetBlock <TIn> block, DataflowOptions options = null, string name = null) { var flow = FromBlock(block, options ?? DataflowOptions.Default); flow.Name = name; return(flow); }
public DataflowMerger(Dataflow <T1, T2> b1, Dataflow <T2, T3> b2, DataflowOptions options) : base(options) { m_b1 = b1; m_b2 = b2; m_b1.GoTo(m_b2); RegisterChild(m_b1); RegisterChild(m_b2); }
/// <summary> /// Construct an DataBroadcaster instance /// </summary> /// <param name="copyFunc">The copy function when broadcasting</param> /// <param name="dataflowOptions">the option of this dataflow</param> public DataBroadcaster(Func <T, T> copyFunc, DataflowOptions dataflowOptions) : base(dataflowOptions) { m_copyBuffers = ImmutableList <Dataflow <T, T> > .Empty; m_transformBlock = new TransformBlock <T, T>( async arg => { T copy = copyFunc == null ? arg : copyFunc(arg); foreach (var buffer in m_copyBuffers) { await buffer.SendAsync(copy).ConfigureAwait(false); } return(arg); }, dataflowOptions.ToExecutionBlockOption()); RegisterChild(m_transformBlock); }
/// <summary> /// Constructs a Dataflow instance /// </summary> /// <param name="dataflowOptions">The dataflow option object</param> public Dataflow(DataflowOptions dataflowOptions) { m_dataflowOptions = dataflowOptions; m_defaultLinkOption = new DataflowLinkOptions() { PropagateCompletion = true }; m_completionTask = new Lazy <Task>(GetCompletionTask, LazyThreadSafetyMode.ExecutionAndPublication); string friendlyName = Utils.GetFriendlyName(this.GetType()); int count = s_nameDict.GetOrAdd(friendlyName, new IntHolder()).Increment(); m_defaultName = friendlyName + count; if (m_dataflowOptions.FlowMonitorEnabled || m_dataflowOptions.BlockMonitorEnabled) { StartPerformanceMonitorAsync(); } }
/// <summary> /// Constructs a simple dataflow from an transformMany delegate /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="transformMany">an transformMany delegate to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the transformMany func</returns> /// <remarks>Uses a TransformManyBlock internally</remarks> public static Dataflow <TIn, TOut> FromDelegate <TIn, TOut>(Func <TIn, IEnumerable <TOut> > transformMany, DataflowOptions options) { return(FromBlock(new TransformManyBlock <TIn, TOut>(transformMany), options)); }
/// <summary> /// Constructs a simple dataflow from an transform delegate /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="func">an transform delegate to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the transform func</returns> public static Dataflow <TIn, TOut> FromDelegate <TIn, TOut>(Func <TIn, TOut> func, DataflowOptions options) { return(FromBlock(new TransformBlock <TIn, TOut>(func), options)); }
/// <summary> /// Constructs a simple dataflow from an Action delegate /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <param name="action">an Action delegate to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the action</returns> public static Dataflow <TIn> FromDelegate <TIn>(Action <TIn> action, DataflowOptions options) { return(FromBlock(new ActionBlock <TIn>(action), options)); }
/// <summary> /// Constructs a simple dataflow from an propagator block /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="block">an propagator block to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the propagator block</returns> public static Dataflow <TIn, TOut> ToDataflow <TIn, TOut>(this IPropagatorBlock <TIn, TOut> block, DataflowOptions options) { return(FromBlock(block, options)); }
/// <summary> /// Constructs a simple dataflow from an propagator block /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="block">an propagator block to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <param name="name">Name of the returned dataflow</param> /// <returns>A dataflow that wraps the propagator block</returns> public static Dataflow <TIn, TOut> ToDataflow <TIn, TOut>(this IPropagatorBlock <TIn, TOut> block, DataflowOptions options = null, string name = null) { var flow = FromBlock(block, options ?? DataflowOptions.Default); if (name != null) { flow.Name = name; } return(flow); }
public TransformManyDataflow(Func <TIn, Task <IEnumerable <TOut> > > transformMany, DataflowOptions options) : base(options) { this.m_transformMany = transformMany; m_block = new TransformManyBlock <TIn, TOut>(new Func <TIn, Task <IEnumerable <TOut> > >(Transform), options.ToExecutionBlockOption()); RegisterChild(m_block); }
/// <summary> /// Constructs a simple dataflow from an target block /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <param name="block">an target block to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the target block</returns> public static Dataflow <TIn> FromBlock <TIn>(ITargetBlock <TIn> block, DataflowOptions options) { return(new TargetDataflow <TIn>(block, options)); }
public TargetDataflow(ITargetBlock <TIn> block, DataflowOptions dataflowOptions) : base(dataflowOptions) { m_block = block; RegisterChild(m_block); }
/// <summary> /// Construct an DataDispatcher instance /// </summary> /// <param name="dispatchFunc">The dispatch function</param> /// <param name="keyComparer">The key comparer for this dataflow</param> /// <param name="option">Option for this dataflow</param> public DataDispatcher(Func <TIn, TKey> dispatchFunc, EqualityComparer <TKey> keyComparer, DataflowOptions option) : base(option) { m_destinations = new ConcurrentDictionary <TKey, Lazy <Dataflow <TIn> > >(keyComparer); m_initer = key => new Lazy <Dataflow <TIn> >( () => { var child = this.CreateChildFlow(key); RegisterChild(child); child.RegisterDependency(m_dispatcherBlock); return(child); }); m_dispatcherBlock = new ActionBlock <TIn>(async input => { var childFlow = m_destinations.GetOrAdd(dispatchFunc(input), m_initer).Value; await childFlow.SendAsync(input).ConfigureAwait(false); }, option.ToExecutionBlockOption()); RegisterChild(m_dispatcherBlock); }
/// <summary> /// Construct an DataDispatcher instance /// </summary> /// <param name="dispatchFunc">The dispatch function</param> /// <param name="option">Option for this dataflow</param> public DataDispatcher(Func <TIn, TKey> dispatchFunc, DataflowOptions option) : this(dispatchFunc, EqualityComparer <TKey> .Default, option) { }
/// <summary> /// Constructs an instance of a log reader /// </summary> public LogReader(DataflowOptions dataflowOptions) : base(dataflowOptions) { }
/// <summary> /// Construct an DataBroadcaster instance /// </summary> /// <param name="dataflowOptions">the option of this dataflow</param> public DataBroadcaster(DataflowOptions dataflowOptions) : this(null, dataflowOptions) { }
/// <summary> /// Constructs a simple dataflow from an propagator block /// </summary> /// <typeparam name="TIn">The input type of the Dataflow</typeparam> /// <typeparam name="TOut">The output type of the Dataflow</typeparam> /// <param name="block">an propagator block to wrap</param> /// <param name="options">The dataflow option for the new dataflow instance</param> /// <returns>A dataflow that wraps the propagator block</returns> public static Dataflow <TIn, TOut> FromBlock <TIn, TOut>(IPropagatorBlock <TIn, TOut> block, DataflowOptions options) { return(new PropagatorDataflow <TIn, TOut>(block, options)); }
public PropagatorDataflow(IPropagatorBlock <TIn, TOut> block, DataflowOptions dataflowOptions) : base(dataflowOptions) { m_block = block; RegisterChild(m_block, null); }