Found 22 packages
A thread-safe int32 struct implemented on top of Interlocked/Volatile operations.
A thread-safe int implemented on top of Interlocked/Volatile operations.
Through a fluent, extensible interface, NBuilder allows you to rapidly create test data, automatically assigning values to properties and public fields that are one of the built in .NET data types (e.g. ints and strings). NBuilder allows you to override for properties you are interested in using lambda expressions.
Straightforward `nint` and `nuint` native integers, written in IL, probably second best to proper compiler support.
Builds on type of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass int values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments cover -1 to -15, 0 to 15, powers of 2 up to 65536, and more. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Ints; // Const type arguments: public readonly struct _8 : K_Int<_8> { public static int Value => 8; } public readonly struct _32 : K_Int<_32> { public static int Value => 32; } public abstract class DefaultSize : Int<_32> { } // Usage: public class Foo<TSize> where TSize : K_Int { public static readonly int[] FooArray = new int[TSize.Value]; static Foo() { Console.WriteLine($"Array size is {FooArray.Length}"); } } // Elsewhere var foo = new Foo<_8>(); // Outputs "Array size is 8" foo = new Foo<DefaultSize>(); // Outputs "Array size is 32"
Hierarchical state machine with fluent definition syntax Features: states and events can be defined with enums, strings or ints - resulting in single class state machines, actions on transitions, entry and exit actions, transition guards, hierarchical with different history behaviors to initialize state always to same state or last active state, fluent definition interface, synchronous/asynchronous state machine (passive state machine handles state transitions synchronously, active state machine handles state transitions asynchronously on the worker thread of the state machine), extensible thorough logging, state machine report for description of state machine (csv, yEd)
Convert ints into Guids and vice versa, to avoid enumeration leaks in your application. Use Guids for your API endpoints and ints in your database and put Guint in between. Have your cake and eat it too!
Forever Factory makes it super easy to build many customized objects. You can define factories for your objects, with all the default values you'll need, or create one on the fly. In each test, you can further customize the objects usings lambdas to override public properties and fields like strings, ints, floats, etc.
Automatic convention based population of test objects. Also includes a number of useful helper methods such as generating random strings, ints, doubles, generic lists & property types such as email, urls, postalcodes, telephone numbers etc. Multi Language data generation including English, Traditional Chinese, Pinyin, Russian, German, Spanish & Italian character sets.
A fast sorting algorithm for all datatypes using IComparable(ints, floats, decimals, strings, etc.).Outperforms generic mergesorts and leverages parallel processing for larger arrays.
A data structure that is a set of integer values. It works 2 times faster than HashSet<int> and takes up much less memory.
Notice Board Models
Extensiones de Objetos (Arrays, List, String, Date, Enum, ints, image ...)
This product is meant to provider an easy way of comparing Range values. For now the comparision is made for struct values such as ints, doubles, DateTime, etc
Make CSVs easier for any object (reference types) or any built in .Net type(strings, ints, booleans, etc), using any enumerable(custom Enumerables, any Collection, any Set, etc).
Hierarchical state machine with fluent definition syntax Features: * states and events can be defined with enums, strings or ints - resulting in single class state machines. * actions o on transitions o entry and exit actions * transition guards * hierarchical o different history behaviors to initialize state always to same state or last active state * fluent definition interface * synchronous/asynchronous state machine o passive state machine handles state transitions synchronously o active state machine handles state transitions asynchronously on the worker thread of the state machine * extensible thorough logging * state machine report for description of state machine bbv.Common.StateMachine is a part of bbv.Common, a library of .NET components and functionality including: * (a)synchronous notification component with thread switching using publisher-subscriber pattern, * hierarchical state machine with fluent definition syntax, * programmatic, loosely coupled, context based rule engine, * support for active objects to build multi-threaded applications
IntSchool.Sharp.Core is a API implmentation of IntSchool API
ExtCore provides extensions to the F# core library (FSharp.Core) and aims to help you build industrial-strength F# applications. These extensions include additional functions for modules such as Array, List, Set, and Map; immutable IntSet, IntMap, LazyList, and Queue collections; a variety of computation expressions (workflows); and "workflow collections" -- collections modules which have been adapted to work seamlessly from within workflows.
WALnutDB is a simple, safe embedded database for .NET 8+. It’s built for devices with little RAM and slow flash (SD cards, eMMC). It uses Write-Ahead Logging (WAL) for power-loss durability, compacts data into sorted segment files (SST), and provides secondary indexes and time-series scans. Fully managed (no native deps), cross-platform, and async by default. Highlights Power-loss safety: WAL with per-frame CRC, truncation-tolerant replay. Async I/O everywhere: designed for slow media and small RAM. Document tables: pluggable serialization (e.g. System.Text.Json); GUIDs/strings/byte[] keys. Secondary indexes: range scans over string/bytes/ints/floats/decimal (with scale). Time-series mode: UTC-ordered keys, efficient range scans by time. Checkpoint & SST: flush memtables to sorted segments, fast reads, WAL truncation. Cross-platform: Linux/Windows/macOS; file-per-table for fault isolation. No native dependencies: pure C# for easy deployment on IoT. Roadmap: online compaction/defrag stats & swap, unique index enforcement, optional encryption-at-rest, richer query push-downs.