/// <summary>
/// Begin a parallel transformation chain by consuming any <see cref="IEnumerable{T}" />.
/// </summary>
/// <remarks>
/// This method will use a default number of threads which is almost certainly sub-optimal.
/// Manually test several different thread counts for each step in order to optimize your transformation chain.
/// Generally IO bound steps should have more threads as they are going to be idle waiting on IO rather than consuming
/// CPU.
/// Generally CPU bound steps should have fewer threads as those threads are going to be idle much less.
/// </remarks>
/// <typeparam name="TProduce">The type of item produced by this transformation.</typeparam>
/// <typeparam name="TConsume">The type of item consumed by this transformation.</typeparam>
/// <param name="source">An enumerable of the initial objects.</param>
/// <param name="transform">The delegate that performs the transformations.</param>
/// <returns>An <see cref="ITransformer{TProduce, TConsume}" /> suitable for parallel processing of transformation steps.</returns>
public static ITransformer <TProduce, TConsume> BeginTransformMany <TProduce, TConsume>(this IEnumerable <TConsume> source, TransformMany <TProduce, TConsume> transform)
{
// Turn the source into an IProcuderConsumerCollection
var consume = CastOrWrap(source);
// Create a thread-safe producer consumer from this enumerable
return(new TransformerMany <TProduce, TConsume>(consume, transform));
}
/// <summary>
/// Add a new transformation to a chain.
/// </summary>
public static ITransformer <TProduce, TConsume> ThenTransformMany <TProduce, TConsume, TOriginal>(this ITransformer <TConsume, TOriginal> transformer, TransformMany <TProduce, TConsume> transform, int threads)
{
return(new TransformerMany <TProduce, TConsume>(transformer.Produce, transform, transformer, threads));
}
/// <summary>
/// Creates a new TransformerMany instance.
/// </summary>
public TransformerMany(IProducerConsumerCollection <TConsume> consume, TransformMany <TProduce, TConsume> transform, ITransformer dependentTransformer, int threads)
: base(consume, dependentTransformer, threads)
{
_transform = transform;
}
/// <summary>
/// Creates a new TransformerMany instance.
/// </summary>
public TransformerMany(IProducerConsumerCollection <TConsume> consume, TransformMany <TProduce, TConsume> transform, ITransformer dependentTransformer)
: this(consume, transform, dependentTransformer, dependentTransformer.ThreadCount)
{
}
/// <summary>
/// Creates a new TransformerMany instance.
/// </summary>
public TransformerMany(IProducerConsumerCollection <TConsume> consume, TransformMany <TProduce, TConsume> transform, int threads)
: this(consume, transform, null, threads)
{
}
/// <summary>
/// Creates a new TransformerMany instance.
/// </summary>
public TransformerMany(IProducerConsumerCollection <TConsume> consume, TransformMany <TProduce, TConsume> transform)
: this(consume, transform, null, DefaultThreadCount)
{
}
