_Strategies to Get Rid of NullReferenceException.png

dotnet6.tar.gz

dotnet6job

NullReferenceException is an error that programmers frequently encounter, and it is often referred to as the Billion Dollar Mistake. This course is designed to assist you in avoiding this error.

You will begin by gaining an understanding of when NullReferenceException is thrown and how to prevent null in your code. You’ll also learn how to employ nullable operators to simplify null checks and use nullable references and the Option wrapper to identify problematic code blocks. Finally, you will explore avoiding NullReferenceException when using specific LINQ methods and designing your C# classes.

Upon completing this course, you’ll have gained the necessary knowledge and skills to effectively address and avoid NullReferenceException issues in your projects.

Mastering NullReferenceException Prevention in C#

With C# 8.0 nullable references, we can tell when an object reference might be `null`. We have type hints for that. The statement `Movie movie` is different from the statement `Movie? movie`.

We only have nullable references available if we're using recent C# versions with .NET Core 3.0 and upward. But, if we're using older versions, we can use an alternative from functional languages: the `Option` type.

# The `Option` type

Functional languages, like F# or Haskell, use a different approach for `null` and optional values. Instead of `null`, they use an `Option` or `Maybe` type.

With the `Option` type, we have a box that might have a value. It's the same concept of nullable primitive types. We briefly mentioned them before. Let's write an example using nullable `int` to see how it relates to the `Option` type.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

int? maybeAnInt = null;

var hasValue = maybeAnInt.HasValue;
Console.WriteLine(hasValue);

try
{
    var dangerousInt = maybeAnInt.Value;
    //                            ^^^^^
    // Nullable object must have a value.
}
catch (InvalidOperationException)
{
    Console.WriteLine($"{nameof(maybeAnInt)} has no value.");
}


var safeInt = maybeAnInt.GetValueOrDefault();
Console.WriteLine(safeInt);

With nullable primitive types, we have the `HasValue` property to check if a variable has a value different from `null` before using it. It's dangerous if we try to use the `Value` property directly since it might be `null`. We also have a `GetValueOrDefault()` method to safely retrieve the value of the nullable type or its default value.

We started our example by declaring a nullable variable with `int? maybeAnInt` and then assigned it to `null` in **line 1**. Then, by mistake, we retrieved its value without checking if it was `null` in **line 8**. This is not a good idea. It threw an `InvalidOperationException`. And then, we retrieved its value safely using `GetValueOrDefault()` instead in **line 18**.

Under the hood, C# uses a wrapper for nullable primitive types: `Nullable<T>`. But for simplicity, we use the `?` at the end of type declarations.

We can extend this concept to reference types by wrapping them around the `Option` type, like `Option<int>` or `Option<Movie>`.

## `Some`, `None`, and `Map`

The `Option` type has two subtypes: `Some` and `None`. `Some` represents a box with a value inside, and `None` represents an empty box. Other languages use `Just` and `Nothing` instead of `Some` and `None`.

Let's start by describing two basic methods of the `Option` type. Among others, the `Option` type has:

* One method to put a value into a box.


Learn an alternative to nullable references: the Option type.

Use the Option Wrapper

The Option type

The `Option` type