30 packages tagged with “Sequential”
Will generate Sequential Guids based on MongoDB's ObjectId specification. Date & time are encoded into the value so you do not need to store them separately in your database. Supports standard Guids as well as SQL Server guids.
Sequential Guid (COMB) for SqlServer/MySQL/Oracle/PostgreSQL.
Simple, fast generation of RFC4122 UUIDS. Features: - Generate RFC4122 version 1 or version 4 UUIDs - Runs in node.js and all browsers. - Cryptographically strong random # generation on supporting platforms - 1.1K minified and gzip'ed - Annotated source code
This library brings C#'s concept of 'await foreach' to F#, with a seamless implementation of IAsyncEnumerable<'T>. The 'taskSeq' computation expression adds support for awaitable asynchronous sequences with similar ease of use and performance to F#'s 'task' CE, with minimal overhead through ValueTask under the hood. TaskSeq brings 'seq' and 'task' together in a safe way. Generates optimized IL code through resumable state machines, and comes with a comprehensive set of functions in module 'TaskSeq'. See README for documentation and more info.
Simple SequentiaGuid generator
Provide extension methods to round trip between NodaTime Instant and sequential guid
Library to create and use COMB (timestamped sequential) GUID variants for Microsoft SQL Server and PostgreSQL. See the GitHub site for more details.
Simple library with helpful classes/functions that make it easier to work with tasks and async/await. (SequentialTaskRunner, CancelableTaskRunner, AsyncLock, ...)
Provides sequential pagination functionality.
Implement MongoDB's IIdGenerator interface and add registration BsonSerializer helper method
Features * Flexible scheduling to the minute (See http://code.google.com/p/ncrontab/) * Multiple execution queues * Designed with Ioc in mind
Per-key sequential execution atom with global parallelism and optional fair scheduling.
Library generate data, based on clear specification
Sequential guid generator
Took the code from https://www.codeproject.com/Articles/388157/GUIDs-as-fast-primary-keys-under-multiple-database and made myself a reusable nuget to be able to make db-specific sequential guids.
Sequential GUID generator for .NET (COMB style, SQL Server-friendly).
Synchronise Resources using Blocking behaviour. (Assume that all resources can be run in parallel, apart from some that are flagged to only run with no other resources in action). In the context of Specflow, scenarios can be flagged to run alone using traits. Prevents test runners having to edit the assembly info and rebuild between sequential/parallel run contexts. Hopefully at some point the Specflow bods autogenerate this sort of this, but not yet, so here we are.
Sequential string ID generator.
A class library for managing multi-threaded sequential write access to one or more files. It is capable of flushing writes from multiple threads in batches by either hitting a specified size threshold or a specified inactivity time limit. It is also possible to write this batching information within the output file(s). Note: This class should be injected as a single or static instance shared across all process threads. Files will be locked exclusively from the first Write() call until FlushAndClose() or Dispose() is called (presently one of these *must* be explicitly called to ensure all data is flushed). The ConcurrentFileWriter class can be found as an extension of System.IO *** Full debugging source/symbols are available from http://srv.symbolsource.org/pdb/Public Usage Example: var cfw = new ConcurrentFileWriter(new ConcurrentFileWriterSettings { flushTimeInMilliseconds = 5000, flushSizeInBytes = 10000, showWriteBatchingMarkers = true }); //Pre-lock file (not required) cfw.Write(@"c:\temp\test.log", null); //Append a string (byte arrays can also be directly written) cfw.WriteUtf8Line(@"c:\temp\test.log", "Test Line"); //Flush and unlock specified file (stop managing) cfw.CloseManagedFile(@"c:\temp\test.log"); //Flush and unlock all managed files cfw.Dispose();
A high-performance sequential dispatcher that enables decoupled application rules to run in-line with the calling thread. Ideal for scenarios like cookie synchronization, real-time security validation, and immediate side effects.
A lightweight, AOT-compatible job runner for executing tasks sequentially with support for dynamic job enqueueing, custom contexts, and comprehensive execution callbacks.
Analyzer that warns that you have have dependency free Tasks which are currently being run sequentially instead of in parallel
JobQueue is a lightweight, thread-based sequential task queue designed for .NET applications. It allows you to enqueue jobs that are processed one by one in the exact order they were added. The jobs are executed on a dedicated background thread, and each job is delivered to a registered callback method.
GUID Version 7 (RFC 9562) ID generation extension for FS.EntityFramework.Library with comprehensive Domain-Driven Design (DDD) support. Provides timestamp-based sequential GUIDs with zero external dependencies, perfect for enterprise .NET 9+ applications requiring RFC-compliant, chronologically ordered unique identifiers for Aggregate Roots and Domain Entities.
DotTorch Layers is a high-performance, modular neural network layers library for .NET 8 and .NET 9. It includes core layers such as Linear, ReLU, Sequential, Dropout, Embedding, Sigmoid, SoftMax, Tanh, LeakyReLU, GELU, ELU, and Flatten. Advanced recurrent layers like RNN, LSTM, and GRU are also implemented, along with powerful Transformer layers. The package features normalization layers: LayerNorm (currently not optimized) and BatchNorm (optimized, with LayerNorm mode support). All layers seamlessly integrate with the DotTorch.Core autograd system, enabling automatic differentiation and backpropagation. Designed for ease of use, extensibility, and efficient execution on CPU and GPU devices. This library supports modern .NET frameworks and follows best practices for maintainability and performance in machine learning model construction.
DotTorch.Optimizers provides first-class implementations of gradient-based optimization algorithms for training neural networks in .NET 8 and .NET 9 environments. The library includes essential optimizers such as SGD, Momentum, RMSprop, Adam, and more. It is fully compatible with DotTorch.Core and supports dynamic computation graphs, automatic differentiation, and batched parameter updates. Optimizers can be seamlessly integrated into training loops and customized for research and production use. Designed with extensibility, testability, and high-performance execution in mind, it empowers developers to efficiently train deep learning models on CPU and GPU.
The Marathon library provides a .NET, cross-platform, lightweight task running library. It facilitates the composition of functions for sequential and parallel execution, or both. Further, it provides synchronous and asynchronous implementations of the composed tasks in a transparent manner to the user. Leveraging the Task Parallel Library is even easier, clearer, and more expressive when using Marathon.
ULID ID generation extension for FS.EntityFramework.Library with full Domain-Driven Design (DDD) support. Provides chronologically sortable, human-readable unique identifiers perfect for enterprise microservice architectures, Aggregate Roots, and Domain Entities. Includes automatic generation, Entity Framework optimizations, and comprehensive DDD integration.
Generate sequential GUIDs that MS SQL Server can sort by date (for mapping to the 'uniqueidentifier' datatype)