Eliminate redundant null checks: method decomposition and nullability in c#

Everything about nullability is great in c#. But how should we deal with it when decomposing code?

Imagine that we have one big method. It receives some object, check important fields for null and than processes them. Property is considered by compiler as non-null till the end of method:

        private class Person
        {
            public string? Name { get; set; }
        }
        
        //before
        private void Do(Person person)
        {
            if (person.Name is null)
                return;
            Console.WriteLine(person.Name.Contains("John"));
            Console.WriteLine(person.Name.Length);
        }

This method is big so we must decompose it into set of small ones:

      
        //after
        private void Do(Person person)
        {
            WriteIfNameIsJohn(person);
            WriteNameLength(person);
        }

        private void WriteNameLength(Person person)
        {
            if (person.Name != null)
                Console.WriteLine(person.Name.Length);
        }

        
        private void WriteIfNameIsJohn(Person person)
        {
            if (person.Name != null)
                Console.WriteLine(person.Name.Contains("John"));
        }

But now we should check property for null at the beginning of each new method! If we created three methods - check three times! For each "Exctract method" action it is needed to add null check.

Possible, but verbose and unclean solution is to use some sort of "Verified" type and pass it to new methods:

        private class VerifiedPerson : Person
        {
            public override string Name { get; set; }
            
            private VerifiedPerson(string name)
            {
                Name = name;
            }

            public static VerifiedPerson? GetVerifiedOrNull(Person person) =>
                person.Name is { } name
                    ? new VerifiedPerson(name)
                    : null;
        }

How to eliminate those checks in elegant way? Maybe it is possible to pass somehow null state of object's property?

Thanks)

One simple solution is to not check for null in those methods. This leaves the verification to the caller, but since all the methods are private that should be acceptable. Now the object is still being verified, but only in one place. It's up to you to be sure not to call those helper methods without first validating the arguments, though:

private void Do(Person person)
{
    if (person?.Name != null)
    {
        WriteIfNameIsJohn(person);
        WriteNameLength(person);
    }
}

private void WriteNameLength(Person person)
{
    Console.WriteLine(person.Name.Length);
}

private void WriteIfNameIsJohn(Person person)
{
    Console.WriteLine(person.Name.Contains("John"));
}

And if the validation checks are cumbersome, they could be pulled out into a helper method:

private bool IsValid(Person person)
{
    if (person == null) return false;
    if (person.Name == null) return false;
    // etc...
    return true;
}

private void Do(Person person)
{
    if (IsValid(person))
    {
        WriteIfNameIsJohn(person);
        WriteNameLength(person);
    }
}

I agree Rufus, no-one forces you to check for null, in particular when all those methods are private and therefor under your control. There's no way the member can ever be null in any of those private methods.

We can help the compiler using the null-forgiving-operator !, e.g:

private void WriteNameLength(Person person)
{
    Console.WriteLine(person.Name!.Length);
}

However I'd argue when your logic is so huge, it may be worth considering to extract a new class from the method and make the name a member of that class. Then you can easily erform the check once within the class` constructor and forget about any nulls in all the private methods.

//after
private void Do(Person person)
{
    if(person.Name is null) return;

    var writer = new NameWriter(person.Name);
    writer.WriteIfNameIsJohn();
    writer.WriteNameLength();
}

class NameWriter
{
    private readonly string name; // name is not nullable here
    public MyClass(string name) { this.name = name }

    public void WriteNameLength()
    {
        // no need for any null-checks here
        Console.WriteLine(this.name.Length);
    }
}

You can find solutions based on how you define your new methods.

Change the Parameters

If the parent method does the null checks on some parameters, you can directly pass those the child methods instead of passing the initial object.

Example: Here I validate Person.Name and I then pass that validated name to the other methods.

private void Do(Person person)
{
    if(person.Name is null)
        return;

    WriteIfNameIsJohn(person.Name);
    WriteNameLength(person.Name);
}

private void WriteNameLength(string name)
{
   Console.WriteLine(name.Length);
}

private void WriteIfNameIsJohn(string name)
{
    Console.WriteLine(name.Contains("John"));
}

In other words, you can avoid the double-checking by splitting the code into more specialized methods that don't require the full object (Person) but instead work with the minimum (just the Name).

Use Local Functions

If you absolutely need the original full object, you can also leverage local functions. These allow to extract code while keeping the scope of the original method.

private void Do(Person person)
{
    if(person.Name is null)
        return;

    WriteIfNameIsJohn();
    WriteNameLength();

    void WriteNameLength()
    {
        Console.WriteLine(person.Name.Length);
    }

    void WriteIfNameIsJohn()
    {
        Console.WriteLine(person.Name.Contains("John"));
    }
}