Understanding GUID, UUID, and ULID in C#

Introduction

When designing distributed systems and databases, ensuring the uniqueness of identifiers across systems, sessions, or records is a critical task. GUID (Globally Unique Identifier), UUID (Universally Unique Identifier), and ULID (Universally Unique Lexicographically Sortable Identifier) are popular solutions for generating unique IDs.

In this article, you'll discover.

What GUID, UUID, and ULID are,
Their differences and use cases,
How to implement them in C#, and
A performance-oriented analysis of their suitability for specific applications.

What are GUID, UUID, and ULID?

1. GUID (Globally Unique Identifier)

A GUID is a 128-bit unique identifier widely used in Microsoft-based systems. While GUID is a term Microsoft uses, it is essentially a UUID (as specified in RFC 4122). By nature, GUIDs guarantee uniqueness across distributed systems by relying on either randomness or timestamp-based generation strategies.

Format: GUIDs are typically represented as a 36-character hexadecimal string with hyphens.

XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

Example: f47ac10b-58cc-4372-a567-0e02b2c3d479

Key Properties

Uniqueness: Globally unique across systems.
Randomness: Commonly generated with UUID v4 (random generation).

Primary Use Cases

Unique Primary Keys in distributed databases.
Globally unique API keys, session tokens, and resource identifiers.
Identification of components/resources in Microsoft technologies like COM (.NET Class IDs).

2. UUID (Universally Unique Identifier)

A UUID is an international standard for generating unique 128-bit identifiers, defined under RFC 4122. Conceptually, GUID and UUID are nearly identical, though UUID strictly follows the RFC and is widely used across non-Microsoft frameworks.

Format: UUID adopts the same format as GUID.

XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

Example: 550e8400-e29b-41d4-a716-446655440000

Key Properties

Cross-platform Compatibility: Supported by programming languages like Python, Java, Go, and Node.js.
Determinism: Using UUID v3/v5 allows deterministic generation for the same inputs.

Primary Use Cases

Unique IDs in distributed services and databases.
Assigning identifiers to resources in cross-platform systems.
APIs and microservices need universal identifiers.

3. ULID (Universally Unique Lexicographically Sortable Identifier)

A ULID is a 128-bit identifier designed to overcome the shortcomings of GUID/UUID in sorting scenarios. ULIDs embed timestamp information into the identifier, making them lexicographically sortable (i.e., they can be sorted naturally based on their textual representations).

Format: Base32-encoded string without special characters.

01GZHT44KMWWT5V2Q4RQ6P8VWT

First 48 bits: Millisecond timestamp (ensures natural ordering).
Last 80 bits: Random entropy.

Key Properties

Ordered: Unlike GUID/UUID, ULIDs are naturally sortable because the timestamp is embedded upfront.
Readable: Fewer characters than UUID (Base32 encoding instead of Base16/Hex).

Primary Use Cases

Log and Event Tracking: Create lexicographically ordered event logs.
High-Frequency Inserts: Reduce database index fragmentation compared to GUIDs/UUIDs.
Human-readable, unique IDs.

Comparing GUID, UUID, and ULID: Features and Suitability

Aspect	GUID	UUID	ULID
Bit Size	128 bits	128 bits	128 bits
Encoding	Hexadecimal	Hexadecimal	Base32
Sorting	Not Sortable	Not Sortable	Lexicographically Sortable
Contains Timestamp?	Optional	Optional	Yes
Write Performance	High Fragmentation in DB Index	High Fragmentation in DB Index	Low Fragmentation (Sequential IDs)
Primary Use	Microsoft systems	Cross-platform, API, databases	Logging, time-ordered systems

Use Cases for GUID, UUID, and ULID

When to Use GUID

Microsoft Ecosystems: COM components, .NET assemblies, and Azure Services utilize GUIDs extensively.
Distributed Databases: Ensures unique keys even when records are written independently across systems.
Session Tracking: Use a GUID to assign globally unique session IDs.

When to Use UUID

Cross-Platform Compatibility: Works across distributed applications and languages like Python, Java, .NET.
APIs and Microservices: Generate identifiers for resources shared across multiple systems.
Randomized Unique IDs: UUID v4 is ideal for cases requiring uniqueness without predictable patterns.

When to Use ULID

Logging Systems: Generate sortable, unique IDs to track events or logs while maintaining a time correlation.

Performance Analysis for Databases

Database Indexing

GUID/UUID: IDs generated randomly (e.g., v4) lead to non-sequential inserts in clustered indexes, resulting in index fragmentation.
ULID: ULID's sequential nature (timestamp) ensures that inserts are ordered naturally, reducing index fragmentation.

Example Performance Metrics (MySQL/PostgreSQL)

Metric	GUID/UUID	ULID
Insert Speed	Slower (Random Inserts)	Faster (Sequential Inserts)
Index Fragmentation	High	Low
Query Performance	Moderate	Better
Storage	16 bytes per ID	16 bytes per ID

Implementing GUID, UUID, and ULID in C#

1. GUID in C#

The System.Guid class provides built-in support for creating GUIDs.

using System;

class Program
{
    static void Main()
    {
        Guid guid = Guid.NewGuid();
        Console.WriteLine($"Generated GUID: {guid}");
    }
}

2. UUID in C#

In .NET Core and Framework, Guid is already a UUID generator (v4 by default).

using System;

class Program
{
    static void Main()
    {
        // Generate a UUID (same as GUID)
        Guid uuid = Guid.NewGuid();
        Console.WriteLine($"Generated UUID (v4): {uuid}");
    }
}

3. ULID in C#

The .NET ecosystem does not natively support ULIDs, but several libraries like Ulid can be used.

Steps

Install UlidSharp from NuGet
```
dotnet add package Ulid
```

Generate ULID

class Program
{
    static void Main()
    {
        // Generate a ULID
        var ulid = Ulid.NewUlid();
        Console.WriteLine($"Generated ULID: {ulid}");
    }
}

Test Samples

Test Samples

Best Practices

GUID/UUID
- Avoid using GUIDs/UUIDs as a primary key in clustered indexes unless uniqueness is more critical than performance.
- Where possible, consider surrogate keys for better performance.
ULID
- Use ULIDs in time-sensitive applications or logs.
- Ideal for high-concurrency, high-volume systems like IoT devices or analytics workloads.

Conclusion

GUID, UUID, and ULID each offer distinct advantages based on the application's requirements.

If you're developing in the Microsoft ecosystem or need universal uniqueness, GUIDs/UUIDs are excellent.
If your application requires ordering, low index fragmentation, and better performance for high-insert workloads, ULID is a superior option.

By understanding the strengths and limitations of each, you can optimize your systems for unique identifier performance, scalability, and order requirements!

3 Comments

Join the conversation! Your thoughts help the community grow.

Joonatan5mo ago
Great article! It’s fantastic to see ULIDs getting more traction in the .NET ecosystem as they solve so many pain points regarding database indexing and readability. While Cysharp/Ulid is a well-known implementation, I’ve been working on ByteAether.Ulid to address a few specific areas of the ULID specification that are often overlooked. Specifically, it implements strict monotonicity for sub-millisecond generation and utilizes a cryptographically secure random generator by default. I’ve also focused on making it more "production-resilient" by using random increments to mitigate enumeration attacks and ensuring ID generation is overflow-safe, so developers don't have to worry about wrapping generation in try-catch blocks. If anyone is looking for a highly spec-compliant and secure version for their projects, feel free to check it out on GitHub! Thanks for sharing this guide!
Didier1y ago
Ulid is not implented in postgresql
- Ayush Gupta1y ago
  You are right, Although PostgreSQL doesn't natively support ULIDs. But You can use third-party extensions that add ULID support to PostgreSQL. Anyway PostgreSQL has native support for UUID, which satisfies the needs of most use cases (ensuring uniqueness across distributed systems).Though ULIDs are becoming popular, their primary advantages (like lexicographical sortability) can often be achieved through workarounds (e.g., timestamps with UUIDs).