--- title: "C# Null-Conditional (?.) & Null-Coalescing (??) Operators Explained — Ivan Kahl" description: "C#'s null-conditional and null-coalescing operators handle null values gracefully, resulting in cleaner and more robust code. Each is explained with examples." url: https://ivankahl.com/blog/csharp-null-conditional-and-null-coalescing-operators-explained/ published: 2025-01-01T00:00:00.000Z tags: - "C#" - "Programming" - "Quick Tip" - "Guides" --- 01 Jan 2025 · 4 min read # C# Null-Conditional (?.) & Null-Coalescing (??) Operators Explained C#'s null-conditional and null-coalescing operators handle null values gracefully, resulting in cleaner and more robust code. Each is explained with examples. You’ve likely bumped into the pesky `NullReferenceException` if you’ve developed anything in C#. This exception usually happens when you try to access a member of a variable that contains a null reference, disrupting the flow of your application. Fortunately, C# offers some handy tools to help you navigate these null reference issues: the null-conditional and null-coalescing operators. These operators provide ways to handle potential null values gracefully while keeping your code clean and readable. > **Update in .NET 10** > > With the release of .NET 10, you’ll be able to use null-conditional operators when *assigning* values as well. Read more about it [here](https://ivankahl.com/blog/csharp-14-null-conditional-assignments/). In this article, you will learn precisely how each operator works, when they should be used, and code samples demonstrating them in action. ## What is the Null-Conditional Operator? The null-conditional operator (`?.`) is a [unary operator](https://www.techopedia.com/definition/25643/unary-operator-c) in C# that checks if a variable is null *before* accessing its members. If the variable is null, the expression short-circuits and evaluates to null, preventing a `NullReferenceException` from being thrown. > **What is short-circuiting?** > > **Short-circuiting** means that if any part of a chained expression evaluates to null, the remaining parts are skipped, and the entire expression evaluates to null. > > For example, if `customer?.ContactDetails` is null in the expression `customer?.ContactDetails?.Email?.Work`, then `Email?.Work` is never evaluated, and the expression returns null. This operator is handy when retrieving values from deeply nested properties in an object. For example, suppose you have an object with nested properties. You can use the null-conditional operator to safely access properties deep within the object without explicitly checking for null at each level. This makes your code more concise and readable, especially when dealing with complex data structures. ```csharp // Without null-conditional operator string? name = null; if (customer != null && customer.Address != null) { name = customer.Address.StreetName; } // With null-conditional operator var? name = customer?.Address?.StreetName; ``` In the example above, the second statement using the null-conditional operator achieves the same result as the first, but in a much more succinct way. If either `customer` or `Address` is null, the expression will evaluate to null, preventing a potential `NullReferenceException`. A word of caution: while the null-conditional operator is quite helpful, you should only use it when it makes sense for a property to be null. Otherwise, you might run into some nasty surprises. For example, in the code snippet below, you already know `customer` is not null, so it’s unnecessary to use the operator on that variable: ```csharp // Previously in the same code block: if (customer is null) throw new CustomerNotFoundException(); // With null-conditional operator on everything (bad) var streetNumber = customer?.Address?.Street?.Number; // With null-conditional operator on nullable properties (good) var streetNumber = customer.Address?.Street?.Number; ``` While the example above might be harmless, there are cases where it can lead to strange bugs. For example, an expression might be evaluated as null, but it could be caused by a property in the expression chain you don’t expect. ## What is the Null-Coalescing Operator? The null-coalescing operator is a [binary operator](https://www.techopedia.com/definition/23953/binary-operator) that offers a concise method to manage null values. If the left operand if it is not null, it returns that; otherwise, it returns the right operand. The syntax looks like this: ```csharp result = value1 ?? value2; ``` In this case, if `value1` is not null, the `result` will be assigned the value of `value1`. However, if `value1` is null, the `result` will be assigned the value of `value2`. This is useful when providing a default value for a nullable variable. For example, you might want to display a default value if a customer’s address is a null string: ```csharp var customerAddress = customer?.Address; var displayAddress = customerAddress ?? "Unknown Address"; ``` If the customer’s address is specified, it’ll be assigned to `displayAddress`. Otherwise, `"Unknown Address"` will be assigned to the variable. You can even use the null-coalesce operator with the null-conditional operator shown above. For example, the above snippet could be combined into a single line like this: ```csharp var displayAddress = customer?.Address ?? "Unknown Address"; ``` Now, if the `customer` variable is null, the null-conditional operator will short-circuit the expression and return `null`. However, since we have a null-coalesce operator in the same line, `"Unknown Address"` is assigned to the `displayAddress` variable instead. You can also use the null-coalescing operator in an assignment operation (`??=`). This is useful if you have an existing variable and only want to assign a value if the current value is null. The snippet below demonstrates this: ```csharp var customerName = customer?.Name; // Without null-coalesce assignment operator customerName = customerName ?? "No name provided"; // With null-coalesce assignment operator customerName ??= "No name provided"; ``` Like the null-conditional operator, only use this operator when it makes sense. It’s easy to fall into the habit of blindly assigning default values without considering whether they make sense. Sometimes, a null is the best option: ```csharp // Here we assign "0" if a street number is not specified in // an address... but does that make sense? address.StreetNumber = request.Address.StreetNumber ?? "0"; ``` In the example above, a default value of `"0"` is assigned to `StreetNumber` if none is specified in the request object. However, this can be confusing. Imagine that the address is used for a delivery, and the driver mistakenly gets lost looking for a house with street number 0. In this case, it’s probably better to leave it blank or null if it’s not applicable. ## Conclusion You’ve undoubtedly bumped into `NullReferenceExceptions`, and they can be frustrating. Fortunately, C# provides operators specifically designed to streamline null handling and prevent those pesky exceptions from being thrown. The null-conditional operator (`?.`) lets you safely access members of potentially null objects, while the null-coalescing operator (`??`) provides a concise way to supply default values when encountering nulls. Understanding and using these operators appropriately helps you write clear, robust C# code that gracefully handles null values. Tags: [C#](https://ivankahl.com/blog/tags/csharp/), [Programming](https://ivankahl.com/blog/tags/programming/), [Quick Tip](https://ivankahl.com/blog/tags/quick-tip/), [Guides](https://ivankahl.com/blog/tags/guides/)