ExtendedThreading 1.1.0

ExtendedThreading

This package provides extended Threading functionality, built on top of the built-in Threading capabilities of .Net.

Installation

I recommend using the NuGet package: ExtendedThreading however feel free to clone the source instead if that suits your needs better.

Usage

ThreadSignal

This is used to simplify signalling between threads, e.g. when building the Producer/Consumer pattern:

public class ProducerConsumer<T>
{
	private ThreadSignal _signal = new();
	
	public void Produce(T item){
		// produce
		_signal.Pulse(); // Inform consumers that a new item is available
	}

	public void Consume()
	{
		_signal.Wait(); // Will block until an item becomes available
		// consume
	}
}

KeyedMutexSynchronizer

This is used to ensure mutual exclusion based on keys. E.g. for an API where you want to grant only a single thread access to do PUT requests on a per-id basis to prevent race conditions on a per entity basis:

public class OrderController
{
	private readonly KeyedMutexSynchronizer<OrderId> _synchronizer;
	private readonly IOrderService _orderService;

	public OrderController(IOrderService orderService, KeyedMutexSynchronizer<OrderId> synchronizer)
	{
		_synchronizer = synchronizer;
		_orderService = orderService;
	}

	[HttpPut("{id})]
	public async Task PutAsync(OrderId id, OrderModel model, CancellationToken cancellationToken)
	{
		// The code in the lambda expression will be protected by a mutex based on OrderId, no two requests with the same OrderId will execute simultaneously, however two requests with different OrderIds will execute simultaneously like normal
		await _synchronizer.InvokeSynchronizedActionAsync(id, async () => { 
			var order = _orderService.GetOrderAsync(id, cancellationToken);
			order.Update(model)
			await _orderService.PersistOrderAsync(order, cancellationToken);
		}, cancellationToken);
	}
}