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