Fixing NullReferenceException and ArgumentNullException in .NET apps

NullReferenceException and ArgumentNullException are common exceptions in .NET applications.

A NullReferenceException occurs when a program tries to use a reference variable the caller set to null as if it were referencing an object. Essentially, the program tries to access a member (a field or method) of an object that doesn’t exist. This exception may originate from a programming mistake or the incorrect use of object references.

ArgumentNullException occurs when a null argument passes to a method that doesn’t accept null values. The method expects to receive a value but the value isn’t provided or the caller explicitly sets the value as null. You may get this exception if you forget to check for null values or fail to properly validate user input.

These exceptions are particularly common in .NET applications because of how .NET handles object references and method arguments. Consequently, they cause .NET applications to crash or display unexpected behavior.

This article will explore these exceptions, why they occur, and how to handle them.

Prerequisites

To follow this tutorial, you’ll need:

• Microsoft Visual Studio installed on your Windows PC
• Familiarity with .NET and C#

Troubleshooting NullReferenceException and ArgumentNullException

You’ll begin by writing some problematic .NET code to see how these exceptions arise.

NullReferenceException

First, write code that results in the NullReferenceException. For this tutorial, you’ll create a console-based project in Visual Studio.

Start by selecting Create a new project at the startup window. Alternatively, if you have Visual Studio open, choose File > New > Project in the menu bar.

Then, select Console App and click Next:

Next, add the following code to the same file. Execute the project by clicking the play icon:

string myString = null; 
int stringLength = myString.Length;

When you click the run button, the program crashes. The logs reveal that a NullReferenceException caused the crash:

In this code, you first declared a string variable, myString, and set it to null. Then, you attempted to access the Length property of myString. Since myString is null, there’s no Length property to access, so the system throws a NullReferenceException.

There are two ways to fix the code and ensure the program runs successfully. The first method is to confirm that the string is not null before checking its Length property:

string myString = null; 
if (myString != null) 
{ 
int stringLength = myString.Length; 
}

The second method ensures that when you declare the string, it’s initialized as an empty string rather than null:

string myString = ""; 
int stringLength = myString.Length;

ArgumentNullException

Now, you’ll review ArgumentNullException. In the same project, replace the existing code with the following, which creates dictionary and tries to add items to it.

Dictionary<string, int> dict = new Dictionary<string, int%gt;(); 
string key = null; 
int value = 10; 
dict.Add(key, value); // This will throw an ArgumentNullException  

When you click the Run button, this program gives the following output, showing the ArgumentNullException error:

In this example, you’re trying to add a key-value pair to Dictionary by calling the Add method. However, you’re passing a null value as the key, which is not allowed. As a result, the code will throw an ArgumentNullException.

To solve that, you can use if statements to check whether that value is null.

Dictionary<string, int> dict = new Dictionary<string, int%gt;(); 
string key = null; 
int value = 10; 

if (key != null) 
{ 
    dict.Add(key, value); 
} 
else 
{ 
    Console.WriteLine("Cannot add null key to dictionary."); 
}  

Sometimes, you might want to use the ArgumentNullException class to throw an exception. For example, If the parameter is null, you may want the program to throw the exception or provide a default value as a substitute:

void DoSomething(string parameter) 
{ 
if (parameter == null) 
{ 
throw new ArgumentNullException(nameof(parameter)); 
} 

int stringLength = parameter.Length; 
} 
DoSomething(null);  

The code above checks whether the parameter is null using an if statement. If the parameter is null, the program throws an ArgumentNullException, giving an error message indicating which parameter (nameof(parameter)) is set to null.

An alternative solution is to provide a default value for the parameter:

void DoSomething(string parameter) 
{ 
string nonNullParameter = parameter ?? ""; 

int stringLength = nonNullParameter.Length; 
}  

In this code, the null-coalescing operator (??) provides a default value of an empty string ("") if the parameter is null. This allows you to safely use the nonNullParameter variable to access its Length property without triggering an exception—even if the code passes in null for the parameter.

Best practices to avoid NullReferenceException and ArgumentNullException

This section lists some best practices you can follow to avoid NullReferenceException and ArgumentNullException.

Always initialize variables and objects

One of the most common causes of the NullReferenceException is when an application access variables or objects that a user hasn’t initialized. It’s good practice to initialize all variables and objects to an appropriate value, such as an empty string or list. This practice helps prevent a NullReferenceException when you access the variable or object later in the code.

Use nullable types

Nullable types are a feature in C# that allows you to define types, including value types and reference types, that can also have a null value. They’re useful when a variable or object doesn’t always have a value. By using nullable types, you can reduce incidences of ArgumentNullException when passing null values as arguments to methods or constructors.

Use parameter validation

One of the best ways to prevent ArgumentNullExceptions is by using parameter validation. This process involves checking for invalid values in method parameters, including null values, and throwing an ArgumentNullException if it detects an invalid value. It gives you a clear error message that indicates which parameter was null, allowing you to catch issues early.

Use the null-coalescing operator

The null-coalescing operator (??) is a C# operator that provides a default value for a nullable variable or object. You can use this operator to ensure that your code doesn’t throw a NullReferenceException when accessing null values.

Use the null-conditional operator

The null-conditional operator (?.) is a C# operator that allows you to safely access members of an object, preventing NullReferenceExceptions. Use this operator to avoid NullReferenceExceptions when accessing members of null objects.

Use defensive coding practices

By employing defensive coding, you can anticipate potential issues and resolve them quickly when they arise. For example, you can use try-catch blocks to handle exceptions that may occur during runtime. Defensive coding makes your code more robust and less error prone.

Write tests

Testing helps catch issues before they become a problem in production. By writing tests that cover edge cases and unexpected scenarios, you can make your code more resilient to issues that may arise during runtime.

Conclusion

In .NET applications, NullReferenceException and ArgumentNullException are common exceptions that can cause program crashes or unexpected behavior.

The NullReferenceException occurs when a program attempts to use a reference variable that the code set to null, while an ArgumentNullException occurs when a null argument passes to a method that doesn’t accept null values.

To keep NullReferenceException and ArgumentNullException occurrences to a minimum, follow these best practices:

• Initialize variables and objects
• Use nullable types
• Use parameter validation
• Use the null-coalescing and null-conditional operators
• Follow defensive coding practices
• Write tests

By following these best practices, you can write robust code that’s less prone to errors and crashes.