Using the C# Null Coalescing Operator Effectively

The C# null coalescing operator (??) is a binary operator that returns the left-hand operand if it is not null; otherwise, it returns the right-hand operand. It is a concise way to provide a fallback value when dealing with nullable types or reference types that may be null. Consider a common scenario: you read a configuration value that may be null and want to assign a default.

string? configValue = GetConfig("timeout");
string timeout = configValue ?? "30";

Without ??, you would write an explicit conditional:

string timeout = configValue != null ? configValue : "30";

The operator reduces visual noise and makes the fallback intention explicit. It works with any nullable value type or reference type, including strings, collections, and custom classes.

How the Operator Behaves with Nullable Value Types

For nullable value types like int?, ?? unwraps the value and returns the fallback when the underlying value is absent. This is especially useful when converting nullable types to non-nullable ones.

int? maybeCount = GetCount();
int count = maybeCount ?? 0;

The result of the expression is a non-nullable int, so you can pass it directly to methods expecting an int. This avoids the need to call .GetValueOrDefault() or check .HasValue manually.

One subtle behavior: the right-hand operand is evaluated only when the left-hand operand is null. This means the fallback expression is not executed unnecessarily, which can matter when the fallback involves a method call or resource allocation.

string value = GetValue() ?? ComputeExpensiveDefault();

If GetValue() returns a non-null string, ComputeExpensiveDefault() is never called. This lazy evaluation is a performance benefit in cases where the fallback is costly.

Null Coalescing Assignment (??=)

C# 8.0 introduced the null coalescing assignment operator ??=. It assigns the right-hand operand to the left-hand operand only if the left-hand operand is null. This is a shorthand for the common pattern:

if (cache == null)
{
    cache = LoadCache();
}

With ??=, the same logic becomes:

cache ??= LoadCache();

This operator is particularly useful for lazy initialization of fields or properties. For example, a thread-safe lazy cache can be implemented with a lock, but ??= is a concise way to initialize a field on first access when thread safety is handled elsewhere.

private List<Item>? _items;
public List<Item> Items => _items ??= LoadItems();

Here, _items is assigned only when it is null. Subsequent calls return the existing list without invoking LoadItems() again.

Chaining Multiple Null Coalescing Operators

The ?? operator can be chained to select the first non-null value from a series of candidates. This is useful when you have multiple possible sources for a value and want to pick the first that is available.

string name = firstName ?? middleName ?? lastName ?? "Unknown";

The expression evaluates from left to right, stopping at the first non-null operand. If all operands are null, the final fallback is returned. This pattern is more readable than nested conditional expressions.

Keep in mind that the type of the entire expression is the common type of all operands. If the operands are of different types, you may need to cast or use a common base type. For example, mixing string and int would require explicit conversion.

Combining with the Null-Conditional Operator

The null-conditional operator ?. is often used together with ??. The combination allows you to safely access members of an object that may be null and then provide a fallback for the result.

int? length = text?.Length;
int result = length ?? -1;

More concisely, you can write:

int result = text?.Length ?? -1;

The ?. operator returns null if text is null, and the ?? operator then supplies the fallback. This pattern is common when working with optional dependencies or nested objects.

string? city = user?.Address?.City ?? "No city";

This expression safely navigates the object graph and provides a default when any part of the chain is null. It reduces the need for multiple null checks and makes the code more declarative.

Performance and Allocation Considerations

One common concern is whether ?? introduces runtime overhead. The operator is compiled to a simple null check and a conditional branch, similar to an explicit if. There is no boxing or reflection involved for reference types. For nullable value types, the compiler generates a check on the HasValue property, which is also cheap.

However, be aware of the fallback expression's cost. As mentioned earlier, the right-hand operand is evaluated lazily. This is usually beneficial, but if the fallback is a simple constant, the JIT compiler may inline it without any runtime cost. If the fallback is a method call, the call is skipped when the left side is non-null, which can save work.

Another consideration is the type of the operands. When using ?? with nullable value types, the result is a non-nullable value type. This avoids the overhead of a nullable wrapper in subsequent operations. For example, int? arithmetic can be slower than int due to the extra HasValue checks. Using ?? to unwrap the value early can improve performance in tight loops.

Common Pitfalls and How to Avoid Them

One mistake is assuming that ?? handles all null-related logic. It only checks for null, not for empty strings, zero, or other default values. If you need to treat empty strings as missing, you must use a different approach, such as string.IsNullOrEmpty.

string value = GetValue() ?? "default"; // Does not catch empty string

Another pitfall is using ?? with reference types that have overloaded == or != operators. The operator checks for null reference, not equality to a custom null-like value. For example, a type that overrides == to treat a special sentinel as null will not be affected by ??; it still checks the actual reference.

Also, be careful when the right-hand operand is a method that can throw an exception. Because it is evaluated only when the left side is null, the exception will occur only in that branch. This can be intentional, but it may surprise developers who expect the fallback to be evaluated eagerly.

When to Use a Conditional Expression Instead

The ?? operator is not always the best choice. If you need to test a condition other than null, such as checking for an empty string or a sentinel value, a conditional expression (?:) is more appropriate.

string displayName = name != string.Empty ? name : "Anonymous";

Similarly, if the fallback logic is complex and requires multiple statements, a full if block is clearer than a convoluted expression. The goal is to keep the code readable; ?? shines when the fallback is a simple value or a single method call.

For example, when you need to assign a different type based on a null check, you might use ?: because the types can differ more naturally.

object value = maybeInt != null ? maybeInt.Value : "missing";

Here, the result type is object, and ?? would require a cast because int and string have no common type other than object.

Compatibility and Language Version Requirements

The ?? operator has been available since C# 2.0, so it works in virtually all modern C# environments. The ??= operator requires C# 8.0 or later, which is supported in .NET Core 3.x, .NET 5+, and newer versions of the .NET Framework with the latest compiler. If you are targeting an older runtime, you may need to avoid ??= or use a language version that supports it.

Most current projects use C# 9 or later, so ??= is widely available. However, if you are maintaining legacy code, check the project's language version before using the assignment form.

Using the Operator in Expression Trees and LINQ

The ?? operator can be used inside LINQ queries and expression trees, but there are limitations. In expression trees, the operator is supported, but the fallback expression must be a constant or a simple expression that can be represented in the tree. Complex method calls may not be allowed in expression trees depending on the provider.

For example, in Entity Framework queries, you can use ?? to provide a default value for a nullable column:

var result = db.Products.Select(p => p.Discount ?? 0).ToList();

This translates to a SQL COALESCE or ISNULL function, depending on the database provider. The operator behaves consistently with SQL semantics, making it a natural fit for database queries.

When using ?? in LINQ to Objects, there is no special translation; it executes as normal C# code. The same lazy evaluation applies, which can be beneficial when the fallback is expensive.

Final Example: Building a Robust Configuration Reader

To tie together the concepts, consider a configuration reader that uses ?? and ??= to provide defaults and lazy initialization.

public class Config
{
    private string? _connectionString;
    private int? _timeout;

    public string ConnectionString =>
        _connectionString ??= LoadConnectionString();

    public int Timeout =>
        _timeout ??= LoadTimeout();

    private string LoadConnectionString()
    {
        // In a real app, this might read from environment variables or a file.
        return Environment.GetEnvironmentVariable("DB_CONNECTION") ?? "localhost";
    }

    private int LoadTimeout()
    {
        var raw = Environment.GetEnvironmentVariable("TIMEOUT");
        return int.TryParse(raw, out var value) ? value : 30;
    }
}

Here, ??= ensures that the loading methods are called only once, and subsequent accesses return the cached value. The ?? operator inside LoadConnectionString provides a fallback for a missing environment variable. This pattern keeps the configuration logic centralized and avoids repeated null checks.

The null coalescing operator is a small but powerful tool in C#. It reduces boilerplate, makes fallback logic explicit, and integrates well with other null-handling features. By understanding its behavior and limitations, you can write cleaner and more maintainable code.