Why does the '{' throw a NullReferenceException in a static method?

Question

This one is sort of esoteric. I ran into a NullReferenceException while trying to open a form (in the winforms designer) in a winforms project in visual studio 2008. The stack trace points to the fourth line of the following code:

public static class Logger
{
    public static void LogMethodEnter()
    {
        var frame = new StackFrame(1);
        var method = frame.GetMethod();
        Trace.TraceInformation("{0}.{1}.{2}()", method.DeclaringType.Namespace, method.DeclaringType.Name, method.Name);
        Trace.Indent();
    }

    public static void LogMethodExit()
    {
        Trace.Unindent();
    }
}

...meaning the line with the opening curly brace. I've run into the same issue (but not involving the winforms designer) on other projects, and I think it was a threading related issue, but I don't have the code to replicate it.

Why does this happen and why does the exception stack trace point to the line with the curly brace?

Clarification: The null reference exception only happens in the winforms designer. When the application is run, it doesn't throw that error.

Answer 1

I'm guessing that the line numbers are off (the actual reason for that is not as important) and the exception is actually thrown by this expression:

method.DeclaringType.Namespace

And the reason you might see a NullReference exception there is because the new StackFrame(1) expression a couple lines previous can sometimes return an empty frame. An empty frame means the call to .GetMethod() will return null, and there you go.

The reason you sometimes get an empty frame is that the just-in-time compiler can choose to inline short, repeatedly-called methods like the one in your code. That will throw off your call stack so at best you get a higher-level method than you intended, or at worst (in your Main method) there is no higher method and you get null.

Answer 2

My guess is that you have an initialization of a static member somewhere in your class, and that initializer throws a NullReferenceException. Furthermore, I guess you have no static constructor, so your object is marked as beforefieldinit and therefore the NullReferenceException is thrown while your method that uses it is JITed.

Something like:

public static class Logger
{
    private static object x = InitObjectX();
    private static object InitObjectX() {
        x.GetHashCode(); // Will throw since x is null.
    }

    public static void LogMethodEnter() 
    { 
        var frame = new StackFrame(1); 
        var method = frame.GetMethod(); 
        Trace.TraceInformation("{0}.{1}.{2}()", method.DeclaringType.Namespace, method.DeclaringType.Name, method.Name); 
        Trace.Indent(); 
    } 

    public static void LogMethodExit() 
    { 
        Trace.Unindent(); 
    } 
} 

Answer 3

It might be that the .pdb file containing the line information is out of date.

To fix this, rebuild your project and make sure that the creation of .pdb files is enabled in the project settings. For C# projects this can be configured on the Build tab by setting Advanced -> Debug Info to either full or pdb-only.

Answer 4

I think the problem is related to the static method being called before the static object is constructed. I fixed the issue in the winforms project by adding a static constructor.

If I remember correctly, the static constructor locks the entire object while executing.

Answer 5

Pointing to a curly bracket/seemingly incorrect line of code can sometime happen. I think it's simply that the exception occurred on the previous line of code, and Visual Studio for some reason highlights the next line.

At a guess, the program may not break exactly on the line where the exception occurred due to any number of internal and external factors.

Sorry I can't explain this very well.