Guard against null values
Tags: csharp, programming, tutorial, coding
Published: 2023-11-19 08:53:09

In the realm of programming, `null` values are like hidden landmines waiting to explode and cause unexpected runtime errors, lead to incorrect logic, and make debugging harder. One of the most common pitfalls developers face is the dreaded `NullReferenceException`. To navigate this perilous terrain, null-checks become our trusty shields, protecting our code from potential disasters. That's why it's important to check for null values before using an object reference in your code.

### Traditional Null-Check with == Operator

One way to do this is to use the == operator, which compares two operands for equality. For example, you can write:

```csharp
var product = GetProduct();
if (product == null) {
    // Do something if the object is null.
}
```

However, this approach has some drawbacks. The `==` operator can be overloaded by a class, which means that it may not behave as you expect when comparing an object with `null`. For instance, if the class defines a custom equality operator that always returns **true**, then the null check will always fail. 

### The New Kid on the Block: is Operator

To avoid these problems, C# offers a better way to check for **null values:** the **is** operator. The is operator performs a pattern-matching operation on an expression and returns true if it matches a specified pattern. One of the patterns that you can use with the **is** operator **is null**, which matches any null value. For example, you can write:

```csharp
var product = GetProduct();
if (product is null) {
    // Do something if the object is null.
}
```

This way of writing null checks has several advantages. 

- First, the is operator cannot be overloaded by a class, so it will always behave consistently when checking for null values. 
- Second, the is operator is more readable and expressive than the `==` operator, because it clearly states what you are checking for. 
- Third, the is operator supports **negation patterns**, which allow you to check for non-null values as well. For example, you can write:

```csharp
var product = GetProduct();
if (product is not null) {
    // Do something if the object is not null.
}
```

This syntax is available in C# 9 and later versions. It is equivalent to writing:

```csharp
var product = GetProduct();
if (!(product is null)) {
    // Do something if the object is not null.
}
```

But it is more concise and elegant.

### Choosing the Right Null-Checking Technique

With multiple null-checking techniques at our disposal, it's essential to choose the right approach based on the specific requirements of your code. While the traditional == operator remains a valid choice, the is operator and the negation pattern introduced in C# 9 offer more robust and expressive alternatives.

Consider the following factors when deciding on a null-checking technique:

1. **Readability:** Opt for the method that makes your code more readable and understandable. The **is** operator and negation pattern are designed to read like natural language, enhancing code clarity.

2. **Consistency:** Stick to a consistent null-checking approach across your codebase. Consistency reduces cognitive load for developers and promotes maintainability.

3. **Compatibility:** Be mindful of the C# version your project is using. While the `==` operator and is operator are available in earlier versions, the negation pattern requires C# 9 or later.

### Conclusion
In conclusion, the **is** operator is a powerful and convenient way to guard against null values in C#. It provides a consistent, readable, and expressive syntax for performing null checks in your code. You should use it whenever possible instead of the `==` operator to avoid potential errors and confusion.