_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#

So far, we covered that to avoid the `NullReferenceException`:
1. We should check for `null` before accessing the methods or properties of an object.
2. We should reject `null` from our methods when they require some parameters.


Let's look at the new operators C# introduced to simplify our `null` checks: `?.`, `??`, and `??=`. These operators don't prevent us from having `null` in the first place, but they help us simplify our work of checking for `null` values.

# Without nullable operators

Let's start with an example and refactor it to use these new operators.

Let's say we want to find one movie from our catalog to follow its director.

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

string name = null;

var movie = FindMovie();
if (movie == null
    || movie.Director == null
    || movie.Director.Name == null)
{
    name = "Steven Spielberg";
}
else
{
    name = movie.Director.Name;
}

Console.WriteLine($"Follow: {name}");

static Movie FindMovie()
{
    // Imagine this is a database call that might
    // or might not return a movie
    var lordOfTheRings = new Movie("The Lord of the Rings: The Two Towers", 2002, 8.8f)
    {
        Director = new Director("Peter Jackson", new DateTime(1961, 10, 31))
    };

    // To add some randomness and emulate a database call
    // without results
    var random = new Random();
    var bit = random.NextDouble();
    return (bit >= 0.5) ? null : lordOfTheRings;
}

record Movie(string Name, int ReleaseYear, float Rating)
{
    public Director Director { get; set; }
}

record Director(string Name, DateTime BirthDate);

Since the result from `FindMovie()` might be `null`, we need to avoid a `NullReferenceException` before reading the `Director` property of a movie and the `Name` property of a director. Therefore, we check if the movie, director, and name aren't `null` to return our favorite director's name.

# With nullable operators

Now, let's use the new nullable operators instead.

## Null-conditional operator (`?.`)

With the **null-conditional operator** (`?.`), we access a property or method of an object only if the object isn't `null`. Otherwise, the entire expression evaluates to `null`.

For example:

Use nullable operators to simplify null checks.

C# 6.0-8.0 Nullable Operators

Without nullable operators