/// <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);
}
