GitHub - ByteAether/Ulid: A .NET C# library for generating and working with Universally Unique Lexicographically Sortable Identifiers (ULIDs), designed to be globally unique, sortable, human-readable, and AoT compatible, making them ideal for use in distributed systems and databases.

A high-performance, fully compliant .NET implementation of ULIDs (Universally Unique Lexicographically Sortable Identifiers), adhering to the official ULID specification.

Introduction

ULIDs are universally unique, lexicographically sortable identifiers, ideal for distributed systems and time-ordered data due to their sortability and human-readability—advantages GUIDs lack. This library offers a robust, fully compliant .NET implementation, addressing limitations found in other ULID solutions.

This implementation addresses a potential OverflowException that can occur when generating multiple ULIDs within the same millisecond due to the "random" part overflowing. To ensure dependable, unique ULID generation, our solution increments the timestamp component upon random part overflow, eliminating such exceptions. This behavior aligns with discussions in ULID specification issue #39.

This library uniquely addresses the predictability of monotonic ULIDs generated within the same millisecond by allowing random increments to the random component. This mitigates enumeration attack vulnerabilities, as discussed in ULID specification issue #105. You can configure the random increment with a random value ranging from 1-byte (1–256) to 4-bytes (1–4,294,967,296), enhancing randomness while preserving lexicographical sortability.

ULID vs UUIDv7

In the evolution of distributed identifiers, ULIDs represent the definitive successor to both legacy GUIDs and auto-incrementing integers. While modern standards like UUIDv7 attempt to address sortability, the RFC 9562 makes monotonicity optional, allowing implementations (such as the native .NET provider) to sacrifice strict ordering during sub-millisecond bursts. This "lazy" approach reintroduces the very index fragmentation and out-of-order writes that sortable IDs were meant to solve.

ULID addresses this by design, mandating strict lexicographical sortability and monotonic increments. By enforcing these requirements at the specification level rather than leaving them to the implementor's discretion, ULID ensures consistent, high-performance behavior across all environments. This library provides a robust, compliant implementation that guarantees this order, enabling your application to scale without the performance trade-offs of non-deterministic identifiers.

Features

Universally Unique: Ensures global uniqueness across systems.
Sortable: Lexicographically ordered for time-based sorting.
Lock-Free Synchronization: Monotonic generation utilizes a high-performance, lock-free compare-and-exchange (CAS) approach.
Specification-Compliant: Fully adheres to the ULID specification.
Interoperable: Includes conversion methods to and from GUIDs, Crockford's Base32 strings, and byte arrays.
Ahead-of-Time (AoT) Compilation Compatible: Fully compatible with AoT compilation for improved startup performance and smaller binary sizes.
Error-Free Generation: Prevents OverflowException by incrementing the timestamp component when the random part overflows, ensuring continuous unique ULID generation.

These features collectively make ByteAether.Ulid a robust and efficient choice for managing unique identifiers in your .NET applications.

Installation

Install the latest stable package via NuGet:

dotnet add package ByteAether.Ulid

To install a specific preview version, use the --version option:

dotnet add package ByteAether.Ulid --version <VERSION_NUMBER>

Usage

Here is a basic example of how to use the ULID implementation:

using System;
using ByteAether.Ulid;

// Create a new ULID
var ulid = Ulid.New();

// Convert to byte array and back
byte[] byteArray = ulid.ToByteArray();
var ulidFromByteArray = Ulid.New(byteArray);

// Convert to GUID and back
Guid guid = ulid.ToGuid();
var ulidFromGuid = Ulid.New(guid);

// Convert to string and back
string ulidString = ulid.ToString();
var ulidFromString = Ulid.Parse(ulidString);

Console.WriteLine($"ULID: {ulid}, GUID: {guid}, String: {ulidString}");

Filtering by Time Range (LINQ)

Since ULIDs are lexicographically sortable and contain a timestamp, you can use Ulid.MinAt() and Ulid.MaxAt() to generate boundary ULIDs for a specific time range. This allows EF Core to translate these into efficient range comparisons (e.g., WHERE Id >= @min AND Id <= @max) in your database.

public async Task<List<Entity>> GetEntitiesFromYesterday(MyDbContext context)
{
    var startOfYesterday = DateTimeOffset.UtcNow.AddDays(-1).Date;
    var endOfYesterday = startOfYesterday.AddDays(1).AddTicks(-1);

    // Create boundary ULIDs for the time range
    var minUlid = Ulid.MinAt(startOfYesterday);
    var maxUlid = Ulid.MaxAt(endOfYesterday);

    // This query uses the primary key index for high performance
    return await context.Entities
        .Where(e => e.Id >= minUlid && e.Id <= maxUlid)
        .ToListAsync();
}

Advanced Generation

You can customize ULID generation by providing GenerationOptions. This allows you to control monotonicity and the source of randomness.

Example: Monotonic ULID with Random Increments

To generate ULIDs that are monotonically increasing with a random increment, you can specify the Monotonicity option.

using System;
using ByteAether.Ulid;
using static ByteAether.Ulid.Ulid.GenerationOptions;

// Configure options for a 2-byte random increment
var options = new Ulid.GenerationOptions
{
	Monotonicity = MonotonicityOptions.MonotonicRandom2Byte
};

// Generate a ULID with the specified options
var ulid = Ulid.New(options);

Console.WriteLine($"ULID with random increment: {ulid}");

Example: Setting Default Generation Options

You can set default generation options for the entire application. This is useful for consistently applying specific behaviors, such as prioritizing performance over cryptographic security.

using System;
using ByteAether.Ulid;
using static ByteAether.Ulid.Ulid.GenerationOptions;

// Set default generation options for the entire application
Ulid.DefaultGenerationOptions = new()
{
	Monotonicity = MonotonicityOptions.MonotonicIncrement,
	InitialRandomSource = new PseudoRandomProvider(),
	IncrementRandomSource = new PseudoRandomProvider()
};

// Now, any subsequent call to Ulid.New() will use these options
var ulid = Ulid.New();

Console.WriteLine($"ULID from pseudo-random source: {ulid}");

API

The Ulid implementation provides the following properties and methods:

Creation

Ulid.New(GenerationOptions? options = null)
Generates a new ULID using default generation options. Accepts an optional GenerationOptions parameter to customize the generation behavior.
Ulid.New(DateTimeOffset dateTimeOffset, GenerationOptions? options = null)
Generates a new ULID using the specified DateTimeOffset and default generation options. Accepts an optional GenerationOptions parameter to customize the generation behavior.
Ulid.New(long timestamp, GenerationOptions? options = null)
Generates a new ULID using the specified Unix timestamp in milliseconds (long) and default generation options. Accepts an optional GenerationOptions parameter to customize the generation behavior.
Ulid.New(DateTimeOffset dateTimeOffset, ReadOnlySpan<byte> random)
Generates a new ULID using the specified DateTimeOffset and a pre-existing random byte array.
Ulid.New(long timestamp, ReadOnlySpan<byte> random)
Generates a new ULID using the specified Unix timestamp in milliseconds (long) and a pre-existing random byte array.
Ulid.New(ReadOnlySpan<byte> bytes)
Creates a ULID from an existing byte array.
Ulid.New(Guid guid)
Create from existing Guid.
Ulid.MinAt(DateTimeOffset datetime)
Creates the minimum possible ULID value for the specified DateTimeOffset.
Ulid.MinAt(long timestamp)
Creates the minimum possible ULID value for the specified Unix timestamp in milliseconds (long).
Ulid.MaxAt(DateTimeOffset datetime)
Creates the maximum possible ULID value for the specified DateTimeOffset.
Ulid.MaxAt(long timestamp)
Creates the maximum possible ULID value for the specified Unix timestamp in milliseconds (long).

Checking Validity

Ulid.IsValid(string ulidString)
Validates if the given string is a valid ULID.
Ulid.IsValid(ReadOnlySpan<char> ulidString)
Validates if the given span of characters is a valid ULID.
Ulid.IsValid(ReadOnlySpan<byte> ulidBytes)
Validates if the given byte array represents a valid ULID.

Parsing

Ulid.Parse(ReadOnlySpan<char> chars, IFormatProvider? provider = null)
Parses a ULID from a character span in canonical format. The IFormatProvider is ignored.
Ulid.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Ulid result)
Tries to parse a ULID from a character span in canonical format. Returns true if successful.
Ulid.Parse(string s, IFormatProvider? provider = null)
Parses a ULID from a string in canonical format. The IFormatProvider is ignored.
Ulid.TryParse(string? s, IFormatProvider? provider, out Ulid result)
Tries to parse a ULID from a string in canonical format. Returns true if successful.

Properties

Ulid.MinValue
Represents an empty ULID, equivalent to default(Ulid) and Ulid.New(new byte[16]).
Ulid.MaxValue
Represents the maximum possible value for a ULID (all bytes set to 0xFF).
Ulid.Empty
Alias for Ulid.MinValue.
Ulid.DefaultGenerationOptions
Default configuration for ULID generation when no options are provided by the Ulid.New(...) call.
.Time
Gets the timestamp component of the ULID as a DateTimeOffset.
.TimeBytes
Gets the time component of the ULID as a ReadOnlySpan<byte>.
.Random
Gets the random component of the ULID as a ReadOnlySpan<byte>.

Conversions & Interoperability

.AsByteSpan()
Provides a ReadOnlySpan<byte> representing the contents of the ULID.
.ToByteArray()
Converts the ULID to a byte array.
.ToGuid()
Converts the ULID to a Guid.
.ToString(string? format = null, IFormatProvider? formatProvider = null)
Converts the ULID to a canonical string representation. Format arguments are ignored.
Provides implicit operators to and from Guid and string.

Comparison Operators & .NET Interfaces

Supports all comparison operators:
==, !=, <, <=, >, >=.
Implements standard comparison and equality methods:
CompareTo, Equals, GetHashCode.
Implements the following .NET standard interfaces:
IMinMaxValue<Ulid>, IEquatable<Ulid>, IIEqualityComparer<Ulid>, IComparable, IComparable<Ulid>, IComparisonOperators<Ulid, Ulid, bool>, IFormattable, IParsable<Ulid>, ISpanFormattable, ISpanParsable<Ulid>, IUtf8SpanFormattable, IUtf8SpanParsable<Ulid>.

GenerationOptions

The GenerationOptions class provides detailed configuration for ULID generation, with the following key properties:

Monotonicity
Controls the behavior of ULID generation when multiple identifiers are created within the same millisecond. It determines whether ULIDs are strictly increasing or allow for random ordering within that millisecond. Available options include: NonMonotonic, MonotonicIncrement (default), MonotonicRandom1Byte, MonotonicRandom2Byte, MonotonicRandom3Byte, MonotonicRandom4Byte.
InitialRandomSource
An IRandomProvider for generating the random bytes of a ULID. The default CryptographicallySecureRandomProvider ensures robust, unpredictable ULIDs using a cryptographically secure generator.
IncrementRandomSource
An IRandomProvider that provides randomness for monotonic random increments. The default PseudoRandomProvider is a faster, non-cryptographically secure source optimized for this specific purpose.

This library comes with two default IRandomProvider implementations:

CryptographicallySecureRandomProvider
Utilizes System.Security.Cryptography.RandomNumberGenerator for high-quality, cryptographically secure random data.
PseudoRandomProvider
A faster, non-cryptographically secure option based on System.Random, ideal for performance-critical scenarios where cryptographic security is not required for random increments.

Custom IRandomProvider implementations can also be created.

Integration with Other Libraries

ASP.NET Core

Supports seamless integration as a route or query parameter with built-in TypeConverter.

System.Text.Json (.NET 5.0+)

Includes a JsonConverter for easy serialization and deserialization.

EF Core Integration

To use ULIDs as primary keys or properties in Entity Framework Core, you can create a custom ValueConverter to handle the conversion between Ulid and byte[]. Here's how to do it:

1. Create a custom `ValueConverter` to convert `Ulid` to `byte[]` and vice versa:

public class UlidToBytesConverter : ValueConverter<Ulid, byte[]>
{
	private static readonly ConverterMappingHints _defaultHints = new(size: 16);

	public UlidToBytesConverter() : this(_defaultHints) { }

	public UlidToBytesConverter(ConverterMappingHints? mappingHints = null) : base(
		convertToProviderExpression: x => x.ToByteArray(),
		convertFromProviderExpression: x => Ulid.New(x),
		mappingHints: _defaultHints.With(mappingHints)
	)
	{ }
}

2. Register the Converter in ConfigureConventions

Once the converter is created, you need to register it in your DbContext's ConfigureConventions virtual method to apply it to Ulid properties:

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
	// ...
	configurationBuilder
		.Properties<Ulid>()
		.HaveConversion<UlidToBytesConverter>();
	// ...
}

Dapper Integration

To use ULIDs with Dapper, you can create a custom TypeHandler to convert between Ulid and byte[]. Here's how to set it up:

1. Create the ULID Type Handler

using Dapper;
using System.Data;

public class UlidTypeHandler : SqlMapper.TypeHandler<Ulid>
{
	public override void SetValue(IDbDataParameter parameter, Ulid value)
	{
		parameter.Value = value.ToByteArray();
	}

	public override Ulid Parse(object value)
	{
		return Ulid.New((byte[])value);
	}
}

2. Register the Type Handler

After creating the UlidTypeHandler, you need to register it with Dapper. You can do this during application startup (e.g., in the Main method or ConfigureServices for ASP.NET Core).

Dapper.SqlMapper.AddTypeHandler(new UlidTypeHandler());

MessagePack Integration

To use ULIDs with MessagePack, you can create a custom MessagePackResolver to handle the serialization and deserialization of Ulid as byte[]. Here's how to set it up:

1. Create the Custom Formatter

First, create a custom formatter for Ulid to handle its conversion to and from byte[]:

using MessagePack;
using MessagePack.Formatters;

public class UlidFormatter : IMessagePackFormatter<Ulid>
{
	public Ulid Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
	{
		var bytes = reader.ReadByteArray();
		return Ulid.New(bytes);
	}

	public void Serialize(ref MessagePackWriter writer, Ulid value, MessagePackSerializerOptions options)
	{
		writer.Write(value.ToByteArray());
	}
}

2. Register the Formatter

Once the UlidFormatter is created, you need to register it with the MessagePackSerializer to handle the Ulid type.

MessagePack.Resolvers.CompositeResolver.Register(
	new IMessagePackFormatter[] { new UlidFormatter() },
	MessagePack.Resolvers.StandardResolver.GetFormatterWithVerify<Ulid>()
);

Alternatively, you can register the formatter globally when configuring MessagePack options:

MessagePackSerializer.DefaultOptions = MessagePackSerializer.DefaultOptions
	.WithResolver(MessagePack.Resolvers.CompositeResolver.Create(
		new IMessagePackFormatter[] { new UlidFormatter() },
		MessagePack.Resolvers.StandardResolver.Instance
	));

Newtonsoft.Json Integration

To use ULIDs with Newtonsoft.Json, you need to create a custom JsonConverter to handle the serialization and deserialization of ULID values. Here's how to set it up:

1. Create the Custom JsonConverter

First, create a custom JsonConverter for Ulid to serialize and deserialize it as a string:

using Newtonsoft.Json;
using System;

public class UlidJsonConverter : JsonConverter<Ulid>
{
	public override Ulid ReadJson(JsonReader reader, Type objectType, Ulid existingValue, bool hasExistingValue, JsonSerializer serializer)
	{
		var value = (string)reader.Value;
		return Ulid.Parse(value);
	}

	public override void WriteJson(JsonWriter writer, Ulid value, JsonSerializer serializer)
	{
		writer.WriteValue(value.ToString());
	}
}

2. Register the JsonConverter

Once the UlidJsonConverter is created, you need to register it with Newtonsoft.Json to handle Ulid serialization and deserialization. You can register the converter globally when configuring your JSON settings:

using Newtonsoft.Json;
using System.Collections.Generic;

JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
	Converters = new List<JsonConverter> { new UlidJsonConverter() }
};

Alternatively, you can specify the converter explicitly in individual serialization or deserialization calls:

var settings = new JsonSerializerSettings();
settings.Converters.Add(new UlidJsonConverter());

var json = JsonConvert.SerializeObject(myObject, settings);
var deserializedObject = JsonConvert.DeserializeObject<MyObject>(json, settings);

Benchmarking

Benchmarking was performed using BenchmarkDotNet to demonstrate the performance and efficiency of this ULID implementation. Comparisons include NetUlid 2.1.0, Ulid 1.4.1, NUlid 1.7.3, and Guid for overlapping functionalities like creation, parsing, and byte conversions.

Benchmark scenarios also include comparisons against Guid, where functionality overlaps, such as creation, parsing, and byte conversions.

Note:

ByteAetherUlidR1Bc & ByteAetherUlidR4Bc are configured to use a cryptographically secure random increment of 1 byte and 4 bytes, respectively, during monotonic ULID generation.
ByteAetherUlidR1Bp & ByteAetherUlidR4Bp are configured to use a pseudo-random increment of 1 byte and 4 bytes, respectively, during monotonic ULID generation.
ByteAetherUlidP is configured to use a pseudo-random source for the random component during non-monotonic ULID generation.

The following benchmarks were performed:

BenchmarkDotNet v0.15.8, Windows 10 (10.0.19044.7417/21H2/November2021Update)
AMD Ryzen 7 3700X 3.60GHz, 1 CPU, 8 logical and 4 physical cores
.NET SDK 10.0.301
  [Host]     : .NET 10.0.9 (10.0.9, 10.0.926.27113), X64 RyuJIT x86-64-v3
  DefaultJob : .NET 10.0.9 (10.0.9, 10.0.926.27113), X64 RyuJIT x86-64-v3

Job=DefaultJob

| Type            | Method             | Mean        | Error     | Gen0   | Allocated |
|---------------- |------------------- |------------:|----------:|-------:|----------:|
| Generate        | ByteAetherUlid     |  40.5719 ns | 0.6657 ns |      - |         - |
| Generate        | ByteAetherUlidR1Bp |  48.3766 ns | 0.1168 ns |      - |         - |
| Generate        | ByteAetherUlidR4Bp |  49.9384 ns | 0.0914 ns |      - |         - |
| Generate        | ByteAetherUlidR1Bc |  89.6066 ns | 0.6575 ns |      - |         - |
| Generate        | ByteAetherUlidR4Bc |  91.5831 ns | 0.3683 ns |      - |         - |
| Generate        | NetUlid *(1)       | 162.1996 ns | 0.7979 ns | 0.0095 |      80 B |
| Generate        | NUlid *(2)         |  49.6330 ns | 0.1247 ns |      - |         - |

| GenerateNonMono | ByteAetherUlid     |  89.6904 ns | 0.5098 ns |      - |         - |
| GenerateNonMono | ByteAetherUlidP    |  40.9386 ns | 0.1507 ns |      - |         - |
| GenerateNonMono | Ulid *(3,4)        |  39.5954 ns | 0.0592 ns |      - |         - |
| GenerateNonMono | NUlid              |  93.1371 ns | 0.4716 ns |      - |         - |
| GenerateNonMono | Guid *(5)          |  47.6369 ns | 0.1340 ns |      - |         - |
| GenerateNonMono | GuidV7 *(3,5)      |  78.6568 ns | 0.4788 ns |      - |         - |

| FromByteArray   | ByteAetherUlid     |   0.7974 ns | 0.0076 ns |      - |         - |
| FromByteArray   | NetUlid            |   1.4321 ns | 0.0109 ns |      - |         - |
| FromByteArray   | Ulid               |   1.1894 ns | 0.0115 ns |      - |         - |
| FromByteArray   | NUlid              |   1.1603 ns | 0.0105 ns |      - |         - |
| FromByteArray   | Guid               |   1.0478 ns | 0.0084 ns |      - |         - |

| FromGuid        | ByteAetherUlid     |   0.8286 ns | 0.0052 ns |      - |         - |
| FromGuid        | NetUlid            |   2.5073 ns | 0.1470 ns |      - |         - |
| FromGuid        | Ulid               |   2.3504 ns | 0.0776 ns |      - |         - |
| FromGuid        | NUlid              |   0.9781 ns | 0.0437 ns |      - |         - |

| FromString      | ByteAetherUlid     |  15.2724 ns | 0.2616 ns |      - |         - |
| FromString      | NetUlid            |  28.4821 ns | 0.5618 ns |      - |         - |
| FromString      | Ulid               |  17.8202 ns | 0.2157 ns |      - |         - |
| FromString      | NUlid              |  64.0466 ns | 1.4103 ns | 0.0086 |      72 B |
| FromString      | Guid               |  22.5952 ns | 0.4522 ns |      - |         - |

| ToByteArray     | ByteAetherUlid     |   4.6165 ns | 0.1121 ns | 0.0048 |      40 B |
| ToByteArray     | AsByteSpan *(6)    |   0.7794 ns | 0.0064 ns |      - |         - |
| ToByteArray     | NetUlid            |   9.4252 ns | 0.0894 ns | 0.0048 |      40 B |
| ToByteArray     | Ulid               |   4.5432 ns | 0.0997 ns | 0.0048 |      40 B |
| ToByteArray     | NUlid              |   8.5760 ns | 0.1168 ns | 0.0048 |      40 B |

| ToGuid          | ByteAetherUlid     |   0.8083 ns | 0.0102 ns |      - |         - |
| ToGuid          | NetUlid            |  10.4080 ns | 0.0285 ns |      - |         - |
| ToGuid          | Ulid               |   1.2320 ns | 0.0102 ns |      - |         - |
| ToGuid          | NUlid              |   0.7692 ns | 0.0057 ns |      - |         - |

| ToString        | ByteAetherUlid     |  19.1190 ns | 0.2176 ns | 0.0095 |      80 B |
| ToString        | NetUlid            |  23.7245 ns | 0.1987 ns | 0.0095 |      80 B |
| ToString        | Ulid               |  19.8952 ns | 0.2056 ns | 0.0095 |      80 B |
| ToString        | NUlid              |  29.1001 ns | 0.1223 ns | 0.0095 |      80 B |
| ToString        | Guid               |   7.9173 ns | 0.0257 ns | 0.0115 |      96 B |

| CompareTo       | ByteAetherUlid     |   1.3642 ns | 0.0089 ns |      - |         - |
| CompareTo       | NetUlid            |   4.7076 ns | 0.0190 ns |      - |         - |
| CompareTo       | Ulid               |   6.7843 ns | 0.0188 ns |      - |         - |
| CompareTo       | NUlid              |   9.1551 ns | 0.0284 ns |      - |         - |
| CompareTo       | Guid               |   4.7391 ns | 0.0188 ns |      - |         - |

| Equals          | ByteAetherUlid     |   1.1228 ns | 0.0164 ns |      - |         - |
| Equals          | NetUlid            |   1.9661 ns | 0.0091 ns |      - |         - |
| Equals          | Ulid               |   1.1092 ns | 0.0156 ns |      - |         - |
| Equals          | NUlid              |   1.0888 ns | 0.0063 ns |      - |         - |
| Equals          | Guid               |   1.0827 ns | 0.0085 ns |      - |         - |

| GetHashCode     | ByteAetherUlid     |   0.9166 ns | 0.0046 ns |      - |         - |
| GetHashCode     | NetUlid            |   8.9307 ns | 0.0230 ns |      - |         - |
| GetHashCode     | Ulid               |   0.9288 ns | 0.0083 ns |      - |         - |
| GetHashCode     | NUlid              |   7.0085 ns | 0.0312 ns |      - |         - |
| GetHashCode     | Guid               |   0.9337 ns | 0.0068 ns |      - |         - |

Existing competitive libraries exhibit various deviations from the official ULID specification or present drawbacks:

NetUlid: Only supports monotonicity within a single thread.
NUlid: Requires custom wrappers and state management for monotonic generation.
Ulid & GuidV7: Do not implement monotonicity.
Ulid: Utilizes a cryptographically non-secure XOR-Shift for random value generation, with only the initial seed being cryptographically secure.
Guid & GuidV7: The Guid documentation explicitly states that its random component may not be generated using a cryptographically secure random number generator (RNG), and that Guid values should not be used for cryptographic purposes.
AsByteSpan: ByteAether.Ulid provides a AsByteSpan() method to read the underlying byte array as a ReadOnlySpan<byte>.

Furthermore, both NetUlid and NUlid, despite offering monotonicity, are susceptible to OverflowException due to random-part overflow.

This implementation demonstrates performance comparable to or exceeding its closest competitors. Crucially, it provides the most complete adherence to the official ULID specification, ensuring superior reliability and robustness for your applications compared to other libraries.

Prior Art

Much of this implementation is either based on or inspired by existing works. This library is standing on the shoulders of giants.

Contributing

We welcome all contributions! You can:

Open a Pull Request: Fork the repository, create a branch, make your changes, and submit a pull request to the main branch.
Report Issues: Found a bug or have a suggestion? Open an issue with details.

Thank you for helping improve the project!

License

This project is licensed under the MIT License. See the LICENSE file for details.

Name		Name	Last commit message	Last commit date
Latest commit History 80 Commits
.github		.github
assets		assets
src		src
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
LICENSE		LICENSE
README.md		README.md

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

Table of Contents

Introduction

ULID vs UUIDv7

Features

Installation

Usage

Filtering by Time Range (LINQ)

Advanced Generation

Example: Monotonic ULID with Random Increments

Example: Setting Default Generation Options

API

Creation

Checking Validity

Parsing

Properties

Conversions & Interoperability

Comparison Operators & .NET Interfaces

GenerationOptions

Integration with Other Libraries

ASP.NET Core

System.Text.Json (.NET 5.0+)

EF Core Integration

1. Create a custom ValueConverter to convert Ulid to byte[] and vice versa:

2. Register the Converter in ConfigureConventions

Dapper Integration

1. Create the ULID Type Handler

2. Register the Type Handler

MessagePack Integration

1. Create the Custom Formatter

2. Register the Formatter

Newtonsoft.Json Integration

1. Create the Custom JsonConverter

2. Register the JsonConverter

Benchmarking

Prior Art

Contributing

License

About

Topics

Resources

License

Code of conduct

Uh oh!

Stars

Watchers

Forks

Releases 21

Uh oh!

Contributors

Uh oh!

Languages

1. Create a custom `ValueConverter` to convert `Ulid` to `byte[]` and vice versa: