https://github.com/i-e-b/dispatchsharp
A library to make multi-threaded code more testable
https://github.com/i-e-b/dispatchsharp
batch-processing c-sharp production-ready test-driven-development thread-pool threading working
Last synced: 6 months ago
JSON representation
A library to make multi-threaded code more testable
- Host: GitHub
- URL: https://github.com/i-e-b/dispatchsharp
- Owner: i-e-b
- License: bsd-3-clause
- Created: 2013-03-25T17:09:24.000Z (over 12 years ago)
- Default Branch: master
- Last Pushed: 2023-06-12T08:55:54.000Z (over 2 years ago)
- Last Synced: 2025-03-29T11:23:31.068Z (7 months ago)
- Topics: batch-processing, c-sharp, production-ready, test-driven-development, thread-pool, threading, working
- Language: C#
- Homepage:
- Size: 3.5 MB
- Stars: 1
- Watchers: 3
- Forks: 3
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
DispatchSharp
=============
https://www.nuget.org/packages/DispatchSharp/
A library to make multi-threaded dispatch code more testable.
Models a job dispatch pattern and provides both threaded and non threaded implementations.
Getting Started
---------------
Doing a batch of work:
```csharp
void DoBatch(IEnumerable workToDo) {
var dispatcher = Dispatch.CreateDefaultMultiThreaded("MyTask");
dispatcher.AddConsumer(MyWorkMethod);
dispatcher.Start();
dispatcher.AddWork(workToDo);
dispatcher.WaitForEmptyQueueAndStop(); // only call this if you're not filling the queue from elsewhere
}
```
or
```csharp
Dispatch.ProcessBatch("BatchRequests", Enumerable.Range(0, times).ToArray(), i => {
. . .
},
threadCount,
ex => {
Console.WriteLine("Error: " + ex.Message);
}
);
```
Handling long running incoming jobs:
```csharp
dispatcher = Dispatch.CreateDefaultMultiThreaded("MyService");
dispatcher.AddConsumer(MyWorkMethod);
dispatcher.Start();
.
.
.
dispatcher.AddWork(...);
```
Using a polling method to handle incoming jobs in a long-running process:
```csharp
var dispatcher = Dispatch.PollAndProcess("MyService", myPollingSource);
dispatcher.AddConsumer(MyWorkMethod);
dispatcher.Start();
```
with a method defined like
```csharp
void MyWorkMethod(object obj)
{
. . .
}
```
Multiple consumers
------------------
A dispatcher can be given multiple consumers.
In this case, each consumer will get given each work item added.
So with
```csharp
dispatcher = Dispatch.CreateDefaultMultiThreaded("MyService");
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 1, work item {wi};"));
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 2, work item {wi};"));
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 3, work item {wi};"));
dispatcher.Start();
dispatcher.AddWork("1");
Console.WriteLine();
dispatcher.AddWork("2");
Console.WriteLine();
dispatcher.AddWork("3");
Console.WriteLine();
```
We should get output similar to
```
Consumer 1, work item 1; Consumer 2, work item 1; Consumer 3, work item 1;
Consumer 1, work item 2; Consumer 2, work item 2; Consumer 3, work item 2;
Consumer 1, work item 3; Consumer 2, work item 3; Consumer 3, work item 3;
```
Parallelism Modes
-----------------
By default, work items are processed in parallel, with each consumer being run
in sequential order ('work parallel').
If you need to have each work item handled strictly in-order, but each consumer
can be run in parallel, use the 'task parallel' mode:
```csharp
dispatcher = Dispatch.CreateTaskParallelMultiThreaded("MyService");
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 1, work item {wi};"));
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 2, work item {wi};"));
dispatcher.AddConsumer(wi=> Console.Write($" Consumer 3, work item {wi};"));
dispatcher.Start();
```