Threading

1) Unified Concurrency The main mission is to unify usage of heterogeneous synchronization primitives with interface/pattern based Object Oriented approach. Switching between multiple synchronization primitives with one code line change! Agile Development ready solution to synchronization. Easy upgrade from general threading to async/await thanks to the pattern based design! Reduced code complexity. Easy correctness testing. Simplified performance optimization. Currently implemented synchronization primitives cover: - wrapper for the .Net SpinLock, - TicketSpinLock, - Lock replacement of C# lock (Monitor), - wrapper around C# lock (monitor) benchmarking only, - async/await AsyncLock, - async/await AsyncSpinLock, - async/await AsyncTicketSpinLock. https://www.codeproject.com/Articles/1236238/Unified-Concurrency-I-Introduction https://www.codeproject.com/Articles/1237518/Unified-Concurrency-II-benchmarking-methodologies https://www.codeproject.com/Articles/1242156/Unified-Concurrency-III-cross-benchmarking 2) AsyncTesting SequencerUC A strongly typed Sequencer is a powerful threading or async/await based unit testing tool to simplify and test correctness in asynchronous and/or parallel code. The Sequencer allows to simplify control/detection of one or many testing thread flows and allows to deterministically setup testing scenario from unit test method and optionally inject data into the tested code to ensure required state. 3) Concurrent Priority Queues Awaitable Concurrent Priority Queue - Optionally awaitable simple to use Concurrent Priority Queue. https://www.codeproject.com/Articles/1222893/Optionally-Awaitable-Concurrent-Priority-Queue

Various classes related to Threading.

Action Queuing system designed for the Nova project. Branched into this repository after growing enough to be a standalone project. Allows queuing through a manager on several queues. A queue can be created, destroyed or blocked. A blocked queue will not execute anything. Queues are built on top of .NET's dataflow library. Actions that belong to non-existant queues don't get executed. However, they can be marked to run unqueued. Metadata is easy to configure using attributes. (e.g. Blocking, Creational, ...) Action implementation is decoupled from the queuing system. A WPF specific dll has already been made.

Simple key value storage using sqlite (C# - Source file). All member methods are thread-safe, so a instance can be safelly be accessed by multiple threads. All stored items are serialized to json by json.net. Note: this nuget package contains c# source code and depends on .Net 4.0.

Visual Studio 2005 theme for DockPanel Suite with multiple UI thread support. (Not recommended)

OpenShare.Net Threading Library. ConcurrentCache is a new in-memory cache system that is generically typed to IDictionary and is thread safe. Client Pool is generically typed and plays well with TPL (Task Parallel Library) for any disposable clients. See source code on Github by using the project url.

Adds a concept of thread safety to C# and VB so that most threading defects are detected at build-time or in a single-threaded test coverage. Includes a deadlock detection policy and thread dispatching aspects. An official PostSharp pattern library.

Multithreading Plugin Assets for the IronPDF Nuget Package. Allows IronPDF to render PDF documents from HTML using all available system cores. https://ironpdf.com/ Use in place of The IronPdf Nuget Package for highly MultiTheaded applications. Supports: * .Net Core 3.1 and above * .Net 5 (beta)

# EventFlow <table border=0 cellpadding=0 cellspacing=0> <tr> <td width=25%> <img src=./icon-128.png /> </td> <td width=25%> <p> <a href=https://www.nuget.org/packages/EventFlow/><img src=https://img.shields.io/nuget/v/EventFlow.svg?style=flat /></a> </p> <p> <a href=https://docs.geteventflow.net/?badge=latest><img src=https://readthedocs.org/projects/eventflow/badge/?version=latest /></a> </p> </td> <td width=25%> <p> <a href=https://ci.appveyor.com/project/eventflow/eventflow><img src=https://ci.appveyor.com/api/projects/status/51yvhvbd909e4o82/branch/develop?svg=true /></a> </p> <p> <a href=https://gitter.im/rasmus/EventFlow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge><img src=https://badges.gitter.im/Join Chat.svg /></a> </p> <!-- <p> <a href=https://codecov.io/github/eventflow/EventFlow?branch=develop><img src=https://codecov.io/github/eventflow/EventFlow/coverage.svg?branch=develop /></a> </p> --> </td> <td width=25%> Think EventFlow is great,<br/> <a href=https://www.paypal.me/rasmusnu>buy me a cup of coffee</a> </td> </tr> </table> NuGet feeds - Official releases: https://www.nuget.org/packages/EventFlow/ - Builds: https://ci.appveyor.com/nuget/eventflow EventFlow is a basic CQRS+ES framework designed to be easy to use. Have a look at our [getting started guide](https://docs.geteventflow.net/GettingStarted.html), the [do’s and don’ts](https://docs.geteventflow.net/DosAndDonts.html) and the [FAQ](https://docs.geteventflow.net/FAQ.html). ### Features * **CQRS+ES framework** * **Async/await first:** Every part of EventFlow is written using async/await. * **Highly configurable and extendable** * **Easy to use** * **No use of threads or background workers** * **Cancellation:** All methods that does IO work or might delay execution (due to retries), takes a `CancellationToken` argument to allow you to cancel the operation ### Examples * **[Complete](#complete-example):** Shows a complete example on how to use EventFlow with in-memory event store and read models in a relatively few lines of code * **Shipping:** To get a more complete example of how EventFlow _could_ be used, have a look at the shipping example found here in the code base. The example is based on the shipping example from the book Domain-Driven Design - Tackling Complexity in the Heart of Software by Eric Evans. Its _in-progress_, but should provide inspiration on how to use EventFlow on a larger scale. If you have ideas and/or comments, create a pull request or an issue

Set of small low level utilitarian classes: Retrier, ConcurrentObjectAccessor, SolidComPlus, AsyncDisposer, BoundedParallel, DataPipeline and DataReplicator

Package Description

Package Description

Elders.Multithreading.Scheduler

針對執行緒相關的擴充方法與幫助方法

XecMe is a hosting and execution framework. It follows the task oriented design approach for solving the business problems. It is a highly configurable framework to execute batch processes, asynchronous tasks, Windows Service etc. You can simplify your Azure Worker Role development to manage multiple task within the same role

Useful set of extensions and classes for simplifying Dataflow implementations. Part of the "Open" set of libraries.

ReusableTasks is a (nearly) zero allocation Task-like object for use when declaring async methods.

EsWork Libraries

A complete Private Instagram API for .NET. Support: - Create new account with phone number and email. [v180] - Login with Cookies. - Edit Profile, change/remove profile picture. - Upload album (videos and photos) - Upload story (video/photo) to self story and direct thread - Send video/photo/story/profile/link/location to direct - Live functions. - Discover functions. - Search peoples. - IGTV functions. - Business functions. - Shopping functions. - Can pass challenge required and two factor authentication. - and many more. See example projects and wiki pages to find out how this library works.

Redistributable components for package 'PostSharp.Patterns.Threading'. This package should only be installed as a dependency. (This is not the package you are looking for).

A lock free doubly linked list for high concurrency.

https://github.com/0Keith/excogitated.common

Polly.Net40Async is a version of the Polly library for .NET 4.0 with async support via Microsoft.Bcl.Async. Polly allows developers to express resilience policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.

C# implementations of thread-safe PriorityQueue and SkipList for .NET

Provides a thread-safe pseudo-random number generator.

OpenShare.Net Common Library. Many common extension methods for making life simple from IEnumerable, Impersonation, String, WCF Services to Encryption. See source code on Github by using the project url.

Fast and space efficient immutable collections, hash maps, and utilities for performant programming in C#. Split from the DryIoc: https://github.com/dadhi/DryIoc

A multi-threaded high performance Least Recently Used cache with async/await support, compiled for .NET Standard 1.1 and shipped as source-only NuGet package. Read http://www.continuousimprover.com/2016/02/a-least-recently-used-cache-that-you.html for some background information.

boost_thread-vc80. Compiler: Visual Studio 2005 SP1.

SmartIrc4net is a multi-threaded and thread-safe IRC library written in C#. It allows you to communicate with IRC servers. The API features full channel syncing and is split in 3 layers: IrcConnection, IrcCommands and IrcClient.

Unitysync.Async is a library of extension methods that lets you preform async continuations on Task/Task<T> Types. Allowing you to non-blockingly call async methods on the Unity3D main thread and continue on the Unity3D main thread when the Task/Task<T> is completed.

An instanced, dedicated ThreadPool for eliminating "noisy neighbor" problems on the CLR ThreadPool

CodeJam is a set of handy reusable .NET components that can simplify your daily work and save your time when you copy and paste your favorite helper methods and classes from one project to another.

Smart Thread Pool, implemented in .NET

Accurately sleep down to 1 millisecond using High Resolution Native Sleep

This package includes the nanoFramework.System.Threading assembly for .NET nanoFramework C# projects.

Provides types for passing data between producers and consumers. Commonly Used Types: System.Threading.Channel System.Threading.Channel<T>

Utility library to simplify writing asynchronous code which supports .NET 3.5 and newer.

Provides support for managing access and audit control lists for synchronization primitives. Commonly Used Types: System.Security.AccessControl.EventWaitHandleAccessRule System.Security.AccessControl.EventWaitHandleAuditRule System.Security.AccessControl.MutexAccessRule System.Security.AccessControl.MutexAuditRule System.Security.AccessControl.MutexSecurity System.Security.AccessControl.SemaphoreAccessRule System.Security.AccessControl.SemaphoreAuditRule System.Security.AccessControl.SemaphoreSecurity

A plug-in that counts the usage of .NET application resources, including: CPU usage, GC, thread status, support for obtaining status information through web requests (access paths and authentication can be customized), and data will be returned in JSON format.

Static code analyzer to detect common mistakes or potential issues regarding threading and async coding.

[**Deprecated**] Sequencer has moved to the LabApps.Threading.Core package.

A thread-safe, run-once, lazy-loaded ConcurrentDictionary

A Fixed Sized Lazy Queue with locked and unlocked methods that can be used to move data from an asynchronous worker so it can be processed immediately by another thread

Async synchronization primitives, async collections, TPL and dataflow extensions. The JoinableTaskFactory allows synchronously blocking the UI thread for async work. This package is applicable to any .NET application (not just Visual Studio).

Yes, another logger! Fast, efficient and pluggable. Can log to separate logging and auditing providers. Supplied console, and file providers. Thread-global Singleton based, so all the advantages of Singletons without the threading problems. Easy to write additional providers can supply structured logging. Has nested context scopes and "LogTags" - metadata for filtering that doesn't appear in the message. Similar to other loggers such as Serilog, but less sophisticated and simpler to use? I think so, it's why I wrote it!

This package provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity. The System.Collections.Immutable library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.

Package Description

oneAPI Threading Building Blocks (oneTBB)

oneAPI Threading Building Blocks (oneTBB)