Item Rating
0 0

Anyone who has had to write multithreaded software to perform a task such as:

  • To send high volumes of emails
  • Upload an unknown number of files to a server
  • Perform distributed calculations
  • Update stock tickers
  • Create a load balancing service
  • etc

would know the difficulties in making our code execute fast, reliably, or simply getting the software to work. Complex components with complex APIs do not make the job easier, especially when you want to focus on getting the problem you are trying to solve.

Pipeline.NET is a high-performance .NET component that fills this gap by providing a reliable and easy to use API that allows you to schedule an unlimited number of tasks on a limited number of lanes — pipelines.


A pipeline is a lane/channel of execution as opposed to being a thread. Threads that ultimately are used to execute the tasks can move across lanes is ultimately decided by the task runner underlying thread pooling mechanism. This ensures optimal efficiency.


Running a simple test of running 100000 tasks/functions using the code snippet below:

					// Adds two numbers and stored in a 3rd variable
struct Sum
   private readonly int _a;
   private readonly int _b;
   public int Result { get; }

   public Sum(int a, int b)
      _a = a;
      _b = b;
      Result = a + b;

// A seeded random number generator
var randomize = new Random(Guid.NewGuid().GetHashCode());

// The test-case code of creating a new instance of the Sum
// class where the public constructor is executed.
// Addition timing code was used to get the results.
new Sum(randomize.Next(1000), randomize.Next(10000))


OS=Microsoft Windows 10 Pro v10.0.19043 Build 19043 HyperV
Processor=Intel(R) Core(TM) i7-3820 CPU @ 3.60GHz, 3602 Mhz, 3 Core(s), 5 Logical Processor(s)

Pipelines	1	| Warm Up 			| 5 Run Average
Tasks 		1	| 27 ticks * 0ms		| 29.6 ticks * 0.003ms * 0s
Tasks 		100000  | 4662167 ticks * 466ms		| 4880427.8 ticks * 488.0428ms * 0.488s
Pipelines	2	| Warm Up 			| 5 Run Average
Tasks 		1	| 54 ticks * 0ms		| 5.6 ticks * 0.0006ms * 0s
Tasks 		100000  | 3235294 ticks * 323ms		| 3138573.8 ticks * 313.8574ms * 0.3139s
Pipelines	3	| Warm Up 			| 5 Run Average
Tasks 		1	| 24 ticks * 0ms		| 5 ticks * 0.0005ms * 0s
Tasks 		100000  | 2548493 ticks * 254ms		| 2868800.6 ticks * 286.8801ms * 0.2869s
Pipelines	4	| Warm Up 			| 5 Run Average
Tasks 		1	| 25 ticks * 0ms		| 2.6 ticks * 0.0003ms * 0s
Tasks 		100000  | 2004441 ticks * 200ms		| 1946911.6 ticks * 194.6912ms * 0.1947s
Pipelines	5	| Warm Up 			| 5 Run Average
Tasks 		1	| 25 ticks / 0ms		| 4.6 ticks * 0.0005ms * 0s
Tasks 		100000  | 1606587 ticks / 160ms		| 1700659.4 ticks * 170.0659ms * 0.1701s


This component is built using the .NET Standard 2.0 and can be consumed in .NET Framework, .NET Core and .NET 5+ projects.

					// Create scheduler
var scheduler = new PipelineScheduler();

// Add task
scheduler.push(() => DoSomething());

// Start scheduler

Leave a Reply

Product support includes:
  • Answering technical questions related to the product
  • Assistance with reported bugs and issues
  • Assistance with reported bugs and issues
  • Feature requests
Product support does not include
  • Installation services
  • 3rd party assets not provided with the product
Pipeline.NET is a high-performance multi-threaded.NET library that schedules tasks on a limited number of pipelines. This means you can run a million tasks/functions in succession on any number of pipelines/channels ensuring that the tasks are processed continuously and simultaneously without overloading the resources on the device.
A pipeline is a lane of execution. Each task is processed on a pipeline by a task runner. Tasks are run asynchronously with the possibility of reusing a thread across pipelines, ensuring maximum performance with minimum resource usage when processing tasks.
Pipeline.NET allows the developer to run an unlimited number of tasks with minimum effort using a simple API and without writing a lot of code.
Yes. Simply create a PipelineScheduler(), schedule your tasks and start the scheduler.
Pipeline.NET has several scheduling algorithms, including FCFS/FIFO (First Come First Serve or First In First Out) and Priority scheduling. The default scheduling algorithm is FCFS: The tasks added first will be processed first.
Yes, you can create a custom scheduling algorithm by implementing the ITaskScheduler contract and specifying it when creating the PipelineScheduler().
No, pipelines are lanes/channels of execution where tasks are processed asynchronously. Often the underlying thread used to execute tasks can move across pipelines.
Yes, Pipeline.NET uses background threads to process tasks.
Yes, simply implement the ITaskRunner interface and specify your new task runner when creating the PipelineScheduler().
Pipeline.NET is built using .NET Standard 2.0 and can be used in any .NET Framework 4.6.1, .NET Core or .NET 5 application.
Yes. You can use custom task runners to run tasks for specific platforms i.e. WPF using Dispatcher.CurrentDispatcher.InvokeAsync(action).
Yes. Check out the documentation links in the product details sections.
1. The assemblies to include in your .NET project 2. An HTML help system documenting the entire API
1. Queue processing 2. Load balancing 3. Bulk email sending 4. High volume task processing 5. Web crawlers 6. Data mining 7. Searching & tree-based algorithms 8. Distributed processing



Item Information

Last Update: 20 August 2021
Released: 9 August 2021
Version: 1.0
File Size: 37KB
Documentation: Yes
Features Schedule tasks Event notifications Abort long running tasks Native scheduling algorithms Custom Scheduling Algorithms Native task runners Custom task runners