When working with C#, you may encounter a type written as Guid? and wonder what the question mark means. The ? suffix makes a value type nullable, meaning it can hold either a valid Guid value or null. This article explains how nullable types work in C#, why they exist, and how to use them effectively.

The Problem with Value Types and Null

In C#, types fall into two categories:

  • Value types (e.g., int, bool, double, Guid, DateTime) - stored directly on the stack and cannot be null by default.
  • Reference types (e.g., string, object, arrays, classes) - stored on the heap and can be null.

This creates a problem. Consider a database column that allows NULL values for a uniqueidentifier field. How do you represent “no value” in C# when Guid always has a value? By default, an uninitialized Guid is Guid.Empty (00000000-0000-0000-0000-000000000000), but that is still a value — it is not the same as “no value at all.”

Guid id = default; // 00000000-0000-0000-0000-000000000000
// Guid id = null; // Compile error: Cannot convert null to 'Guid'

Introducing Nullable Value Types

C# solves this with the Nullable<T> struct. The shorthand syntax uses a ? after the type name:

// These two declarations are identical
Nullable<Guid> id1 = null;
Guid? id2 = null;

The ? syntax works with any value type:

int? nullableInt = null;
bool? nullableBool = null;
DateTime? nullableDate = null;
double? nullableDouble = null;
Guid? nullableGuid = null;

How Nullable Types Work Internally

Nullable<T> is a struct with two key properties:

  • HasValue - Returns true if the variable holds a value, false if it is null.
  • Value - Returns the underlying value. Throws an InvalidOperationException if HasValue is false.
Guid? optionalId = Guid.NewGuid();

if (optionalId.HasValue)
{
    Console.WriteLine($"ID is: {optionalId.Value}");
}
else
{
    Console.WriteLine("No ID assigned");
}

Guid? vs Guid: When to Use Each

Use Guid (non-nullable) when:

  • The value is always required, such as a primary key.
  • There is no valid scenario where the value should be absent.

Use Guid? (nullable) when:

  • The value is optional, such as a nullable foreign key.
  • You need to distinguish between “not set” and Guid.Empty.
  • Mapping to a database column that allows NULL.
  • Working with API parameters that may or may not be provided.

Entity Framework Example

Nullable GUIDs are especially common in Entity Framework and other ORMs when mapping database schemas:

public class Order
{
    public Guid Id { get; set; }              // Primary key - always required
    public Guid CustomerId { get; set; }      // Foreign key - always required
    public Guid? CouponId { get; set; }       // Optional foreign key - may be null
    public Guid? ApprovedById { get; set; }   // Null until someone approves
}

In this example, CouponId is nullable because not every order uses a coupon. The database column would be defined as uniqueidentifier NULL.

Working with Nullable Guid Values

Null-Coalescing Operator (??)

The ?? operator provides a default value when the nullable is null:

Guid? optionalId = GetOptionalId();
Guid actualId = optionalId ?? Guid.Empty;

Null-Coalescing Assignment (??=)

Introduced in C# 8.0, this assigns a value only if the variable is currently null:

Guid? id = null;
id ??= Guid.NewGuid(); // Assigns a new GUID because id is null

Null-Conditional Operator (?.)

Use this to safely access members when the value might be null:

Guid? id = GetOptionalId();
string? formatted = id?.ToString("D"); // null if id is null

Pattern Matching (C# 7+)

Guid? optionalId = GetOptionalId();

if (optionalId is Guid actualId)
{
    Console.WriteLine($"Has value: {actualId}");
}
else
{
    Console.WriteLine("No value");
}

Common Patterns and Beispiele

Converting Between Guid? and Guid

// Guid? to Guid (with default)
Guid? nullable = GetOptionalId();
Guid nonNullable = nullable ?? Guid.Empty;
Guid nonNullable2 = nullable.GetValueOrDefault();
Guid nonNullable3 = nullable.GetValueOrDefault(Guid.Empty);

// Guid to Guid? (implicit conversion)
Guid id = Guid.NewGuid();
Guid? nullableId = id; // Implicit conversion - always works

Checking for a Meaningful Value

When working with Guid?, you often want to check that it has a value and that the value is not Guid.Empty:

public bool HasValidId(Guid? id)
{
    return id.HasValue && id.Value != Guid.Empty;
}

// Or more concisely
public bool HasValidId(Guid? id)
{
    return id is Guid g && g != Guid.Empty;
}

LINQ Queries with Nullable Guids

List<Order> orders = GetOrders();

// Find orders without a coupon
var noCouponOrders = orders.Where(o => o.CouponId == null);

// Find orders with a specific coupon
Guid targetCoupon = GetCouponId();
var couponOrders = orders.Where(o => o.CouponId == targetCoupon);

// Group by nullable foreign key
var grouped = orders.GroupBy(o => o.ApprovedById);

Method Parameters

public List<Order> SearchOrders(
    Guid customerId,
    Guid? couponId = null,
    Guid? approvedById = null)
{
    var query = dbContext.Orders
        .Where(o => o.CustomerId == customerId);

    if (couponId.HasValue)
        query = query.Where(o => o.CouponId == couponId.Value);

    if (approvedById.HasValue)
        query = query.Where(o => o.ApprovedById == approvedById.Value);

    return query.ToList();
}

Nullable Reference Types (C# 8+)

Starting with C# 8.0 and nullable reference types, the ? annotation extends to reference types as well. However, the behavior is different:

  • Guid? (nullable value type) - Wraps the value in Nullable<Guid>, physically changing the type to allow null.
  • string? (nullable reference type) - A compiler annotation only. The runtime type is still string, but the compiler warns about potential null dereference.
#nullable enable

Guid? nullableGuid = null;    // Nullable<Guid> - runtime support
string? nullableStr = null;   // Compiler annotation - no runtime change

Zusammenfassung

The Guid? type in C# is shorthand for Nullable<Guid>, which allows a Guid value type to hold null. This is essential when working with database columns that permit NULL values, optional parameters, and scenarios where you need to distinguish between “no value” and a default value like Guid.Empty. Use the null-coalescing operator (??), HasValue/Value properties, and pattern matching to work safely with nullable types and avoid runtime exceptions.