What is the cause?

Essentially

You are trying to use some object that is null(or Nothingin VB.NET). This means that either you have initialized it to null, or you never initialized it.

nullis a value like the others, and is passed in the same way. If you have null in method "A", it may be that method "B" has passed a null to method "A".

The rest of this answer is going to go into more detail and show common mistakes many programmers make that can lead to a NullReferenceException.

More specifically

When the runtime launches one NullReferenceException it always means the same thing: you are trying to use a reference. This reference has not been initialized (or was initialized at some point , but is no longer initialized).

This means that the reference is null, and members of a reference cannot be accessed if the reference is null. This is the simplest case:

string variable = null;
variable.ToUpper();

This code will throw one NullReferenceExceptionon the second line, since the instance method cannot be called ToUpper()on a reference of stringpointing to null.

Depuration

How do I find the source of an exception NullReferenceException? In addition to studying the exception itself, which will be thrown in the exact place where it occurs, the general debugging rules in Visual Studio should be applied: set breakpoints strategically and inspect the variables , either by placing the cursor mouse over their names, by opening a (Quick) Watch window, or by using existing debugging panels such as Locals and Auto.

If you want to find where the reference is or is not assigned, right-click on its name and choose "Find all references". You can then put a breakpoint on all found locations and run the program again in debug. Every time the debugger stops execution at that point, you'll need to determine if you expected the reference at that point to be non-null, by inspecting the variable and verifying that it points to an instance when it should.

By following the flow of the program in this way, you will be able to find the location where the instance should not be null, and why it has not been initialized as it should.

examples

Some common scenarios where we can encounter this exception:

generic

ref1.ref2.ref3.miembro

If ref1 or ref2 or ref3 is null, then you will get a NullReferenceException. If you want to solve this problem, then you need to find which one it is by nullrewriting the expression to its simplest equivalent:

var r1 = ref1;
var r2 = r1.ref2;
var r3 = r2.ref3;
r3.miembro

For example, in HttpContext.Current.User.Identity.Name, the HttpContext.Currentcould be null, or the property Usercould be null, or the property Identitycould be null.

class instances

When any reference type (class) variable is created, by default it is initialized to null.

public class Libro {
    public string Titulo { get; set; }
}
public class Ejemplo {
    public void Prueba() {
        Libro b1;
        string titulo = b1.Titulo;  // Nunca has inicializado la variable b1
                                    // asi que no hay ningun libro del que obtener el título
    }
}

Class variables must either be initialized or assigned with an instance of the same class already initialized. Initialization is achieved using the keyword new.

Libro b1 = new Libro();

Hint

public class Persona {
    public int Edad { get; set; }
}
public class Libro {
    public Persona Autor { get; set; }
}
public class Ejemplo {
    public void Prueba() {
        Libro b1 = new Libro();
        int edadAutor = b1.Autor.Edad; // La propiedad Autor nunca ha sido inicializada
                                       // asi que no existe ninguna Persona de la que obtener su edad.
    }
}

If you want to avoid the null reference of the child (Person), you could initialize it in the constructor of the parent (Book).

The same applies to nested object initializers:

Libro b1 = new Libro { Autor = { Edad = 45 } };

Although the keyword is used in this example new, it only creates a new instance of Libro, not a new instance of Persona, so the property Autorremains null.

Arrays

int[] numeros = null;
int n = numeros[0]; // numeros es null. No pueden existir los indices.

Elements of an Array

Persona[] gente = new Persona[5];
gente[0].Edad = 20 // gente[0] es null. El array ha sido asignado en memoria pero no inicializado
                   // No existe ninguna persona para la que asignar la edad.

Irregular Arrays ( Jagged Arrays )

long[][] array = new long[1][];
array[0][0] = 3; // es null porque sólo la primera dimensión ha sido inicializada.
                 // Se debe usar array[0] = new long[2]; primero.

Collections/Lists/Dictionaries

Dictionary<string, int> edadesPorNombres = null;
int age = edadesPorNombres["Bob"]; // edadesPorNombres is null.
                                   // No existe ningún Diccionario donde realizar la búsqueda.

Range variables (Indirect/Deferred)

public class Persona {
    public string Nombre { get; set; }
}
var gente = new List<Persona>();
gente.Add(null);
var nombres = from p in gente select p.Nombre;
string primerNombre = nombres.First(); // La Excepción se lanza aquí, pero en realidad ha ocurrido
                                       // en la línea anterior.  "p" es null porque el primer
                                       // elemento que añadimos a la lista es null

events

public class Demo
{
    public event EventHandler EstadoCambiado;

    protected virtual void OnEstadoCambiado(EventArgs e)
    {        
        EstadoCambiado(this, e); // La excepción es lanzada aquí
                                 // si no existe ningún manejador de eventos acoplado 
                                 // al evento EstadoCambiado
    }
}

Names that do not follow the conventions:

If you had named the fields differently than the local variables, you might have noticed that you never initialized the field.

public class Form1 {
    private Cliente cliente;

    private void Form1_Load(object sender, EventArgs e) {
        Cliente cliente = new Cliente();
        cliente.Nombre = "Juan";
    }

    private void Button_Click(object sender, EventArgs e) {
        MessageBox.Show(cliente.Nombre);
    }
}

This can be worked around by following the convention that fields have an underscore ( _) added before the name:

private Cliente _cliente;

Life cycle of an ASP.NET page:

public partial class EdicionProblemas : System.Web.UI.Page
{
    protected ProblemaTest miProblema;

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            // Solo se llama en la primera carga, no cuando se pulsa el botón
            miProblema= new ProblemaTest(); 
        }
    }

    protected void BotonGuardar_Click(object sender, EventArgs e)
    {
        myProblema.Entrada = "¡NullReferenceException aqui!";
    }
}

ASP.NET Session Values

// si el valor de sesión "Nombre" no ha sido añadido todavía,
// entonces esta línea lanzará una NullReferenceException
string nombre = Session["Nombre"].ToString();

ASP.NET MVC Empty View Models

If the exception occurs when a property is referenced @Modeloin an ASP.NET MVC view, you need to understand that the Modelois initialized in your method action, when you return( return) a view. When you return an empty model (or a model property) from your controller, the exception is thrown when the view accesses it:

// Controlador
public class Restaurante:Controller
{
    public ActionResult Buscar()
    {
         return View();  // Olvidaste proporcionar un modelo aqui.
    }
}

// Razor view 
@foreach (var restauranteBuscar in Model.BuscarRestaurante)  // Se lanza la excepción.
{
}

<p>@Model.algunaPropiedad</p> <!-- tambien se lanza la excepción -->

Creation order of controls and events in WPF

WPF controls are created during the call to InitializeComponentin the order they appear in the visual tree. An exception NullReferenceExceptioncan be thrown if controls created earlier with event handlers, etc. , which fire during InitializeComponent, reference controls created after.

For example:

<Grid>
    <!-- Combobox se declara primero -->
    <ComboBox Name="comboBox1" 
              Margin="10"
              SelectedIndex="0" 
              SelectionChanged="comboBox1_SelectionChanged">
        <ComboBoxItem Content="Elemento 1" />
        <ComboBoxItem Content="Elemento 2" />
        <ComboBoxItem Content="Elemento 3" />
    </ComboBox>

    <!-- Label declarado después -->
    <Label Name="label1" 
           Content="Etiqueta"
           Margin="10" />
</Grid>

Here comboBox1it is created before label1. If the event comboBox1_SelectionChangedtries to reference label1, it has not yet been created.

private void comboBox1_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    label1.Content = comboBox1.SelectedIndex.ToString(); // ¡¡NullReference aquí!!
}

Changing the order of the declarations in the XAML (for example, putting label1before comboBox1, ignoring design philosophy issues), would at least solve the NullReferenceExceptionin this case.

cast withas

var miCosa = unObjeto as Cosa;

This would not throw an InvalidCastException, but would return nullwhen the cast fails (and when unObjetonull). So you have to be careful with it.

LINQ FirstOrDefault() and SingleOrDefault()

The simple versions First()and Single()throw an exception when there is nothing. Versions "OrDefault"return null in that case. You must be aware of it.

foreach

foreachthrows an exception when you try to iterate over a null collection. This is usually caused by an unexpected null result from a method that returns a collection.

 List<int> lista = null;    
 foreach(var v in lista) { } // excepción

A more realistic example - selecting nodes from an XML document. The exception will be thrown if the nodes are not found but an initial debug shows that all properties are valid:

 foreach (var nodo in myData.MyXml.DocumentNode.SelectNodes("//Datos"))

ways to avoid it

Explicitly check nullfor and ignore null values.

If you anticipate that the reference might ever be null, you can ask if it is nullbefore accessing the members of the instance:

void ImprimirNombre(Persona p) {
    if (p != null) {
        Console.WriteLine(p.Nombre);
    }
}

Explicitly check nulland return a default value.

Calls to methods that you expect to return an instance might return null, for example when the object being searched for is not found. You can choose to return a default value in these cases:

string ObtenerCategoria(Libro b) {
    if (b == null)
        return "Desconocida";
    return b.Categoria;
}

Explicitly check nulland throw a custom exception.

You could also throw a custom exception, so you can catch it in the code that calls the method:

string ObtenerCategoria(string titulo) {
    var libro = biblioteca.BuscarLibro(titulo);  // Esto podría devolver null
    if (libro == null)
        throw new LibroNoEncontradoException(titulo);  // Tu excepción personalizada
    return libro.Categoria;
}

Use Debug.Assertif a value should never be null, to catch the problem before the exception is thrown.

When you know in the development stage that a method might return nulleven though this should never happen, you can use Debug.Assert()to stop the program flow as soon as possible when it happens:

string ObtenerTitulo(int libroExistenteID) {
    // Sabes que esto nunca debería devolver null.
    var libro = biblioteca.ObtenerLibro(libroExistenteID);  

    // La excepción se lanzará en la linea siguiente en lugar de la final del método.
    Debug.Assert(libro != null, "Biblioteca no devolvió ningun libro para el ID de un libro existente.");

    // ...otro código...

    return book.Titulo; // Nunca se lanzará una NullReferenceException en modo de depuración(Debug).
}

This check will not be performed on your Release Build , causing it to NullReferenceExceptionbe released again libro == nullat runtime.

Use GetValueOrDefault()in "Nullable" value types ( nullables ) to get a default value when they are null.

DateTime? cita = null;
Console.WriteLine(cita.GetValueOrDefault(DateTime.Now));
// Mostrará el valor por defecto proporcionado (DateTime.Now), porque cita es null.

cita = new DateTime(2022, 10, 20);
Console.WriteLine(cita.GetValueOrDefault(DateTime.Now));
// Mostrará la fecha de la cita, no el valor por defecto

Use the null coalescing operator : ??[C#] or If()[VB].

The shortest way to provide a default value when null is encountered:

IService CrearServicio(ILogger log, Int32? nivel)
{
    var serviceImpl = new MiServicio(log ?? NullLog.Instance);

    // Fíjate que el "GetValueOrDefault()" de arriba puede ser reescrito para usar el operador ??
    serviceImpl.nivel = nivel ?? 5;
}

Use the null condition operator: ?.(available in C# 6 and VB.NET 14):

This operator is also called safe navigation or Elvis (because of its shape). If the expression on the left side of the operator is null, the right side of the operator is not evaluated, and , is returned instead null. In this case:

var titulo = persona.Titulo.ToUpper();

If the person doesn't have a title, this code will throw an exception because it's trying to call ToUpperon a property with a null value.

In C# 5 and below, this can be fixed like so:

var titulo = persona.Titulo == null ? null : persona.Titulo.ToUpper();

Now the variable titulowill be nullinstead of throwing an exception. C# 6 introduces a shorter syntax that does the same thing:

var titulo = persona.Titulo?.ToUpper();

The result of this is that the variable titulowill be assigned null, and the call to ToUpperwill never be made if it persona.Titulois null.

Of course, you still have to check that titleit is not nullor use the null condition operator in conjunction with the null check operator ( ??) to provide a default value:

// comprobación normal de null
int longitudTitulo = 0;
if (titulo != null)
    longitudTitulo = titulo.Length; // Si titulo es null, esto lanzará una NullReferenceException

// combinando los operadores `?` y `??`
int longitudTitulo = titulo?.Length ?? 0;

This answer is a translation of the great answer found on the English version of Stack Overflow

In my case I had a List initialized to null

List<Object> lista = null;

I changed the initialization for the object type and it was solved

List<Object> lista = new List<Object>();