_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 have used the `Option` type as a replacement for `null` and C# 8.0 nullable references when working with previous versions of the C# language. Also, we learned that C#, unlike functional languages, doesn't have a built-in `Option` type. We have to either use a third-party library or write our own `Option` type. Let's write our own lightweight `Option` type to see its inner workings.

# Defining the `Option` class

Let's start by writing an `Option` class with the `Some()`, `None()`, and `Match()` methods.

public class Option<T>
{
    private readonly T _value;
    private readonly bool _hasValue;

    private Option(T value, bool hasValue)
    {
        _value = value;
        _hasValue = hasValue;
    }

    public static Option<T> Some(T value)
    {
        return new Option<T>(value, true);
    }

    public static Option<T> None()
    {
        return new Option<T>(default, false);
    }

    public TResult Match<TResult>(Func<T, TResult> onSome, Func<TResult> onNone)
    {
        return _hasValue ? onSome(_value) : onNone();
    }
}

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

var someInt = Option<int>.Some(42);
var message = someInt.Match(
                    value => $"It has a value. It's {value}",
                    () => "It doesn't have a value");
Console.WriteLine(message);

// TODO: Create a variable, assign it to None, and
// print its value using Match
// var none = ...

Let's take a look at the `Option.cs` file first.

We're using a generic class to put any object we define inside a box. The `Option<T>` class has two private properties: `_value` and `_hasValue` on **lines 3 and 4**, respectively. The first one holds the actual content of a box, and the second tells if the box is empty.

We're not exposing the `_value` variable as a public property or field. We don't want to read it directly when the `Option` represents an empty box.

The `Option` constructor is private on **line 6**. To build a new `Option` instance, we have two static methods, `Some()` and `None()`, on **lines 12 and 17**, respectively. `Some()` receives the value to put into the box, and `None()` doesn't receive any parameters.

> **Note:** With our current implementation, we can call `Some()` with `null`, like `var someString = Option<string>.Some(null);`. We would need a `null` check to prevent it. But let's keep our `Option` class simple.

The `Match()` method receives two functions to unbox the value inside the `Option`. The first, `onSome`, is called when there's a value in the box. Otherwise, `onNone` is called. This `Match()` method will help us write the `Map()` and `FlatMap()` methods later.

With these three methods, we can write a simple example. Let's take a look at the `main.cs` file.

In the `main.cs` file, we create an `Option` to hold an integer: `someInt`. Then, with `Match()`, we build a message to print the value inside the `Option`. We pass two functions to `Match()`. The first one, on **line 3**, uses as a parameter the content of `someInt`. The second one, on **line 4**, doesn't use any parameter since `Match()` only calls this function when `Option` is empty.

# Writing `Map()` and `FlatMap()`

So far, we can only create a new `Option` and project its value with `Match()`. For a more complete version, we need the `Map()` and `FlatMap()` methods. Let's write them.



Implement a lightweight version of the Option type.

Implement Your Option Wrapper

Defining the Option class

Defining the `Option` class