217 packages tagged with “uuid”
A tiny, secure, URL-friendly, unique string ID generator for .NET Core.
A fast and modern .NET library to generate UUID/GUID that are either sequential and database friendly (versions 7), name based (versions 5) or random (version 4).
Provides Newtonsoft.Json serialization support for the UUID library, enabling seamless JSON serialization and deserialization of UUID values. Features include efficient string conversion, comprehensive error handling, and full compatibility with Newtonsoft.Json serialization patterns.
Provides System.Text.Json serialization support for the UUID library, enabling seamless JSON serialization and deserialization of UUID values. Features include efficient string conversion, comprehensive error handling, and full compatibility with System.Text.Json serialization patterns.
The main goal of this library is to provide primitive types like Uuid, Hex converter, etc.
Library to create and use COMB (timestamped sequential) GUID variants for Microsoft SQL Server and PostgreSQL. See the GitHub site for more details.
UUID is a cutting-edge library meticulously crafted for modern distributed systems, offering unparalleled performance and reliability in unique identifier generation. At its core, the library ensures thread safety while maintaining exceptional performance characteristics, making it ideal for high-throughput applications. It generates time-ordered identifiers that enable natural sorting capabilities, while incorporating cryptographic randomness for enhanced security. The library seamlessly integrates with existing systems through its comprehensive Guid compatibility and intuitive conversion operators. It excels in string handling with efficient parsing and formatting capabilities, supporting versatile encoding formats including Base32 and Base64. The implementation features robust comparison and equality operations, complemented by thread-local secure random generation for optimal performance and security. Built with modern development practices in mind, UUID maintains a compact 16-byte binary format and ensures cross-platform compatibility across the .NET ecosystem. The library is backed by extensive test coverage and performance benchmarks, making it a reliable choice for enterprise-grade applications requiring robust unique identifier generation.
Provides Entity Framework Core integration for the UUID library, enabling efficient database storage and mapping of UUID values. Features include binary (16 bytes), string (32 characters), and base64 (24 characters) storage formats, global configuration options, and per-property customization through value converters.
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.
Provides MessagePack serialization support for the UUID library, enabling high-performance binary serialization and deserialization of UUID values. Features include compact binary representation, thread-safe implementation, comprehensive error handling, and seamless integration with MessagePack's type resolution system. Optimized for both performance and memory efficiency across different .NET platforms.
A .Net ULID implementation
Creates GUIDs according to RFC 4122 and RFC 9562.
Provides Dapper type handlers for the UUID library, enabling seamless integration with database operations. Features include binary and string storage options, thread-safe implementation, comprehensive error handling, and efficient database type mapping. Optimized for both performance and flexibility across different .NET platforms and database systems.
C# implementation of UUID v7 time-sortable Guids ("06338364-8305-788f-8000-9ada942eb663"), and an alternative string format Id25 ("0q974fmmvghw8qfathid7qekc").
A library that enables fast generation of version 7 (time-ordered) UUIDs, designed for efficient utilization in databases and resource indexing. It provides conversions to and from GUIDs, multiple string representations, and wide compatibility with .NET 7 and higher, including .NET 4.6.1 and higher (.NET Standard 2.0). Additionally, it supports version 4 (fully random) UUIDs.
The main goal of this library is to provide methods for generating Uuid.
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
Ported from https://github.com/rs/xid - A fast, low allocation, zero config, thread-safe 12 byte UUID generator based on the Mongo Object Id algorithm.
ASP.NET Extensions to make it easy to create and use COMB (timestamped sequential) GUID variants for Microsoft SQL Server and PostgreSQL. See the GitHub site for more details.
Qowaiv is a (Single) Value Object library. It aims to model reusable (Single) Value Objects that can be used in a wide variety of modeling scenarios, both inside and outside a Domain-driven context.
High-performance, buffered KSUID generator for .NET. Optimized for zero-allocation hotspots.
This library implements the following GUID generation algorithms specified in RFC 4122 Version 1: Date-time and MAC address GUID Version 3: MD5 hash & namespace Version 4: Random Version 5: SHA-1 hash & namespace It supports both generating GUIDs as well as parsing them into their constituent components.
A library that provides a way to handle and generate UUIDs. Convert them to and from strings, GUIDs, and the like. The library is written to be fast and efficient when comparing, generating, or handling operations. Provides ways to generate UUIDs from different data, like a string, a byte array, or cutting up a byte array into UUIDs. Complies with the RFC 4122 / RFC 9562 standard. And has version 1-8 UUIDs implemented.
High-performance dotnet implementation of type-safe, K-sortable, globally unique identifier inspired by Stripe IDs
Reliable unique ID generation and management for distributed applications. Auto-increment IDs reveal sensitive information. UUIDs (also known as GUIDs) are inefficient as primary keys in a database. Having two different IDs is cumbersome and counterintuitive. We can do better. - For a 93-bit UUID replacement that is efficient as a primary key, use the DistributedId. - For a 128-bit 128-bit UUID replacement with the advantages of the DistributedId and practically no rate limits or collisions, at the cost of more space, use the DistributedId128. - To expose IDs externally in a sensitive environment where zero metadata must be leaked, transform them with PublicIdentities. https://github.com/TheArchitectDev/Architect.Identities Release notes: 2.1.1: - Enhancement: Upgraded package versions. 2.1.0: - Semi-breaking: IPublicIdentityConverter now features additional methods, although the type is generally not user-implemented. - Semi-breaking: HexadecimalIdEncoder's char-based parameters have been renamed from "bytes" to "chars". - Added DistributedId128, a 128-bit (Guid/UInt128) DistributedId variant with practically no rate limits or collisions that also doubles as a version-7 UUID. - Added encoding methods for UInt128. - Added extension methods to transcode between UInt128 and Guid. - Added public identity conversions for UInt128 and Guid. - DistributedIdGeneratorScope and DistributedId128GeneratorScope now expose the CurrentGenerator property, which helps when implementing generators that need to piggyback on the encapsulated generator. 2.0.0: - BREAKING: Removed Fluid. Ambient scopes with startup configuration are now considered undesirable. - BREAKING: Removed ApplicationInstanceId. Ambient scopes with startup configuration are now considered undesirable. - BREAKING: Removed ambient access to IPublicIdentityConverter. Ambient scopes with startup configuration are now considered undesirable. - BREAKING: IdEncoder has been reworked into BinaryIdEncoder, AphanumericIdEncoder, and HexadecimalIdEncoder. - BREAKING: ID decoding methods now throw if the input is too long. This is specially relevant for strings (such as query parameters) where 0123456789123456 and 0123456789123456aaaa should not produce the same ID. - BREAKING: IPublicIdentityConverter now throws on big-endian architectures, instead of risking silent portability issues between architectures. - BREAKING: Now using AmbientContexts 2.0.0. - Semi-breaking: DistributedIds are now always 28 digits, to avoid a change from 27 to 28 digits in the future. Newly generated IDs will be significantly greater than before. Avoid downgrading after upgrading. - DistributedIds can now burst-generate ~128,000 IDs at once before the ~128 IDs per millisecond throttling kicks in. This makes throttling much less likely to be encountered. - DistributedId now stays incremental even under clock adjustments of up to 1 second. (Note that the UTC clock remains unaffected by DST.) - Hexadecimal ID encodings are now supported. - IPublicIdentityConverter now comes with a TestPublicIdentityConverter implementation for unit tests. - Added UnsupportedOSPlatform("browser") to PublicIdentities, due to continuing lack of AES support. 1.0.2: - Now using AmbientContexts 1.1.1, which fixes extremely rare bugs and improves performance. 1.0.1: - Now using AmbientContexts 1.1.0, for a performance improvement.
Discord inspired, Twitter like implementation of Snowflake IDs, focused on performance. Snowflakes are 64 bit, highly optimized, decentralized, K-ordered, unique identifiers.
Uuid fully compliant with RFC4122
Got an Int? Need a Guid? Get a Gluid. A simple, fast collection of extension methods that allow you to covert regular Int's and Long's to a Guid and back later without clashing with any system generated Guid. Useful for converting legacy Id's to distributed Id's without the need for a look-up table, or even for just hiding number data in a Guid.
Provide extension methods to round trip between NodaTime Instant and sequential guid
Provides RFC 4122/9562 compliant GUID generators for .NET platform.