C# is pretty cool and it features a range of paradigms including strong typing, imperative, declarative, functional, generic, object-oriented, and component-oriented programming disciplines. In this post, let’s talk about one specific aspect of C# – Nullables.

What Are Nullables?

Nullable types are instances of the System.Nullable<T> struct in C#, where T is a value type. A nullable type can represent the normal range of values for its underlying value type, plus an additional null value. This is especially useful when dealing with databases and other data types where a value may be unknown, undefined, or simply not applicable. Non-nullable value types such as int, bool, float, double and DateTime etc, do not accept null values and will produce an error if attempted to assign null.

Why Use Nullables?

Let’s consider a real-world scenario. You’re developing a database for a company that requires storing employees’ details. Among various other pieces of information, you need to record the employee’s yearly bonus. However, not every employee is eligible for a bonus, and for those who aren’t, the bonus field does not apply. How would you deal with this?

Here, nullables come to the rescue. By making the bonus field nullable, you can assign it a value if applicable, or leave it as null when it’s not.

How to Use Nullables?

To declare a nullable type in C#, we use the ? modifier appended to the value type. Here’s an example:

int? nullableInt = null;

In the above code, nullableInt is a nullable integer that is initially assigned the value null.

You can also assign it a regular integer value:

nullableInt = 5;

You can check if a nullable type has a value using the HasValue property:

if (nullableInt.HasValue)
{
    Console.WriteLine($"Value of nullableInt: {nullableInt.Value}");
}
else
{
    Console.WriteLine("nullableInt does not have a value.");
}

Null Coalescing Operator

C# also includes the null coalescing operator (??) which can be very useful when working with nullable types. The operator allows you to define a default value that a nullable type will have if it is indeed null. Here’s how it’s used:

int regularInt = nullableInt ?? defaultInt;

In this code, if nullableInt is null, regularInt will be assigned the value of defaultInt.

Null-Conditional Operators

In C# 6.0 and later, the null-conditional operator ?. lets you access members and elements only when the receiver is not-null, returning null result otherwise.

Consider the following example:

int? length = customers?.Length;

In this case, length will be assigned the value of customers.Length only if customers is not null. Otherwise, length will be assigned null.

Nullable Reference Types

Starting with C# 8.0, nullable reference types have been introduced. Unlike value types, reference types were allowed to be null. But with this feature, you can make your code more explicit about whether a reference type variable can be null or not. This can help to eliminate common null reference exceptions.

string? nullableString = null;

Nullables in C# are a powerful feature that allows you to express intent and deal with the concept of absence or undefined in a controlled and explicit manner. This can significantly reduce runtime errors and improve code quality. It’s a good practice to use nullables when you want to represent the semantic “no value” scenario. It can be used for a wide variety of purposes, such as database interaction, dealing with external services, and much more. By learning and leveraging nullables in your C# code, you can make your applications more robust and reliable.