lawrence-laz / generic-pipeline

A simple, fast and generic implementation of the pipeline design pattern.

GenericPipeline

A general purpose dependency free pipeline builder. https://en.wikipedia.org/wiki/Pipeline_(software)

🌟 Features

• Simplicity: Designed with simplicity in mind, the library offers a straightforward and easy-to-use pipeline implementation.
• High Performance: The library boasts exceptional performance, as demonstrated by its benchmark results.
• No Dispatch-Time Allocations: With the exception of async Task, the library makes no dispatch-time allocations, thus providing a highly efficient pipeline implementation.
• No Dependencies: The library has zero external dependencies, making it lightweight and easy to integrate with other projects.

📦️ Get started

Download from nuget.org:

dotnet add package GenericPipeline

⚖️ Feature parity

	GenericPipeline	MediatR	MessagePipe	PipelineNet	Mediator
Usable without dependency injection	✔️	❌	❌	✔️	❌
Usable with dependency injection	✔️	✔️	✔️	✔️¹	✔️
.NET framework support	✔️	✔️	✔️	✔️	❌
Allocation-free dispatching	✔️	❌	✔️	❌	✔️
Generic request handling	✔️	✔️	✔️	❌	✔️
Async and sync handlers/behaviors	✔️	❌	✔️	✔️	❌
Change handlers at runtime	✔️	❌	❌	✔️²	❌
Behaviors	✔️	✔️	✔️	✔️	✔️
Streams	❌	✔️	❌	❌	✔️
Notifications	❌	✔️	✔️	❌	✔️

¹ ^{- Unity container only,} ² ^{- add only, cannot remove}

⚡️ Benchmarks

Overhead per invocation for each library. Scenario contains a call to a behavior and a handler.

Sync:

Method	Mean	Allocated
Simple method call	5.7 ns	-
GenericPipeline	31.2 ns	-
MediatR	502.8 ns	600 B
PipelineNet	95.4 ns	152 B

Awaited async:

Method	Mean	Allocated
Simple method call	4 863 ns	560 B
GenericPipeline	5 906 ns	864 B
MediatR	6 662 ns	1160 B
PipelineNet	7 017 ns	1184 B

_{Pipe icons created by Smashicons - Flaticon}

generic-pipeline's Issues

Make handlers without return type return `void` instead of `Unit`

This is only to simplify user code, the internal would still use Unit not to create special cases. Can be implemented by having a wrapper that wraps user handler and returns Unit.Value instead.

Add `Pipeline.CanHandle` method to see if request can be handled by the pipeline

• Pipeline and PipelineAsync
• bool CanHandle(Type requestType) for dynamic types
• bool CanHandle<TRequest>() for generic types

Add FAQ section to `readme.md`

Answer questions like:
- Should I use this instead of MediatR and alike?
- Can this be used for implementing CQRS?
- When should I use this?
- Why do I have to specify type parameters on send?
- How sync/async can be used together and when?

Benchmarks vs Mediator

Hi 👋,
have you looked into this library? https://github.com/martinothamar/Mediator (it uses source generators underneath).
Just wondering what would be the benchmarks vs this implementation :)

Add contravariance to handlers

Add `CancellationToken` to async implementation

Add pipeline interfaces

• This will allow mocking for unit tests.
• Check if performance is not impacted, Mediator library for example always allocates memory when dispatching requests via an interface.

Add assembly scanning for `IServiceCollection`

Add benchmarks with more libraries

Test open generic request

Refactor tests to match a single style

Publish debug symbols and source with NuGet package

Request context

Add dependency injection example

Add source link

https://github.com/dotnet/sourcelink

Add a small example to `readme.md`