It means your code used an object reference that was set to null (i.e. it did not refer to an actual object instance).

To prevent the error, objects that could be null should be tested for null before being used.

It means that the variable in question is pointed at nothing. I could generate this like so:

SqlConnection connection = null;
connection.Open();

That will throw the error because while I've declared the variable "connection", it's not pointed at anything. When I try to call the member "Open", there's no reference for it to resolve, and it will throw the error.

To avoid this error:

1. Always initialize your objects before you try to do anything with them...
2. If you're not sure whether the object is null, check it with object == null.

JetBrains' Resharper tool will identify every place in your code that has the possibility of a null reference error, allowing you to put in a null check. This error is the number one source of bugs, IMHO.

Note, regardless of the scenario, the cause is always the same in .NET:

You are trying to use a reference variable who’s value is Nothing/null. When the value is Nothing/null for the reference variable, that means it is not actually holding a reference to an instance of any object that exists on the heap. You either never assigned something to the variable, never created an instance of the value assigned to the variable, or you set the variable equal to Nothing/null manually, or you called a function that set the variable to Nothing/null for you.

An example of this exception being thrown is; when you are trying to check something, that is null.

for example:

string testString = null; //because it doesn't have a value (i.e. it's null, "Length" cannot do what it needs to do)

if(testString.Length == 0) // throws a nullreferenceexception
{
//do something
} 

Other peoples code (e.g. code inside the .net framework) may throw a NullReferenceException, where the code cannot do what it needs to if your code sets it to null i.e. it expects something other than null.

More info here: http://dotnetperls.com/nullreferenceexception

Another case that I don't see mentioned here in the answers is when you cast a null object into a value type. For example, the code below:

    object o = null;
    DateTime d = (DateTime)o;

Will throw a NullReferenceException on the cast. It seems quite obvious in the above sample, but this can happen in more "late-binding" intricate scenarios where the null object has been returned from some code you don't own, and the cast is for example generated by some automatic system.

One example of this is this simple ASP.NET binding fragment with the Calendar control:

<asp:Calendar runat="server" SelectedDate="<%#Bind("Something")%>" />

Here, SelectedDate is in fact a property - of DateTime type - of the Calendar Web Control type, and the binding could perfectly return something null. The implicit ASP.NET Generator will create a piece of code that will be equivalent to the cast code above. And this will raise a NullReferenceException that is quite difficult to spot because it lies in ASP.NET generated code which compiles fine ...

you are using the object that contain the null value reference. so its giving null exception. in the example the string value is null and when check its length the exception occured.

Example:

string value = null;
if (value.Length == 0) // <-- Causes exception
{
    Console.WriteLine(value); // <-- Never reached
}

The exception error is:

Unhandled Exception:

System.NullReferenceException: Object reference not set to an instance of an object. at Program.Main()

Another case where NullReferenceExceptions can happen is the (incorrect) use of the as operator:

class Book {
    public string Name { get; set; }
}
class Car { }

Car mycar = new Car();
Book mybook = mycar as Book;   // Incompatible conversion --> mybook = null

Console.WriteLine(mybook.Name);   // NullReferenceException

Here, Book and Car are incompatible types; a Car cannot be converted/cast to a Book. When this cast fails, as returns null. Using mybook after this causes a NullReferenceException.

In general, you should use a cast or as, as follows:

If you are expecting the type conversion to always succeed (ie. you know what the object should be ahead of time), then you should use a cast:

ComicBook cb = (ComicBook)specificBook;

If you are unsure of the type, but you want to try to use it as a specific type, then use as:

ComicBook cb = specificBook as ComicBook;
if (cb != null) {
   // ...
}

If you have not initialized a Reference Type, and you want to set or read one of its properties, it will throw a NullReferenceException.

Example:

Person p = null;
p.Name = "Harry"; <== NullReferenceException occurs here.

You can simply avoid this by checking if the variable is not null:

Person p = null;
if (p!=null)
{
p.Name = "Harry"; <== not going to run to this point
}

To fully understand why a NullReferenceException is thrown, it is important to know the difference between Value Types and Reference Types.

So, if you're dealing with Value Types, NullReferenceExceptions can not occur. Though you need to keep alert when dealing with Reference Types!

Only Reference Types, as the name is suggesting, can hold references or point literally to nothing (or 'null'). Whereas Value Types always contain a value.

Reference Types: (These ones must be checked)

• dynamic
• object
• string

Value Types: (You can easily ignore these ones)

• Numeric types
• Integral types
• Floating-point types
• decimal
• bool
• User defined structs